Make apps with AI. Share them like documents.
One app file that opens on Mac, Windows, and Linux.
The user sees what it wants to access before it runs.
Website · Try Notes · Make an app · Docs · Releases · Discussions
AI can make useful small apps for one person or one team. Sharing those apps is still hard.
A browser link cannot handle every local use case. A normal desktop app can, but it is tied to an operating system and may reach more of the computer than the user expects.
Krate uses a simpler app format:
- The app and the access it requests go into one
.krate
file. - The same file opens on Mac, Windows, and Linux.
- Krate shows the requested access before the app runs.
- The app receives only the access the user allows.
request
↓
checklist.krate
↓
review access
↓
open on Mac, Windows, or Linux
Krate is open source and currently in pre-alpha.
Install the command line tool on macOS or Linux:
curl -fsSL https://raw.githubusercontent.com/incyashraj/krate/main/scripts/install.sh | sh
Check the installation:
krate --version
Run the public Notes app:
krate run \
https://github.com/incyashraj/krate/releases/download/notes-v0.1.0/notes.krate \
--native-window \
--prompt
Krate fetches the file, shows what it requests, and runs it with the access you approve.
For a guided walkthrough, use Try Krate Notes.
Download the krate-app
zip for your Mac from the
current release.
Unzip Krate.app
, then download notes.krate.
The current app is not signed. On first open:
- Right-click
Krate.app
. - Choose
Open. - Double-click
notes.krate
.
The macOS permission window appears before the Notes app runs.
Download the newest x86_64-pc-windows-msvc.zip
from
Releases, extract
krate.exe
, and place its folder on your PATH
.
Then:
krate --version
krate run https://github.com/incyashraj/krate/releases/download/notes-v0.1.0/notes.krate --native-window --prompt
Windows file association support is available through scripts/install-krate-desktop.ps1.
After installing krate
, register .krate
files for your current user:
git clone https://github.com/incyashraj/krate
cd krate
scripts/install-krate-desktop.sh
You can then open a .krate
file from your file manager.
The current release includes krate create
. It turns a supported request into
a complete .krate
file:
krate create \
"Make a checklist app that saves locally" \
--output checklist.krate
Krate writes the app, builds it, checks what system features it uses, packages it, and confirms that denied access is blocked before writing the file.
The public release has two built-in examples:
- a checklist app with local saving;
- a command line word-frequency app.
Creating an app currently needs Rust, the wasm32-wasip1
target, and
cargo-component
. Check your machine with:
krate doctor
The full guide is Make and share a Krate app.
The built-in examples prove the complete path, but an AI coding agent can write the app from your request instead. With Claude Code installed and signed in:
krate create \
"A grocery list app called My Groceries" \
--agent claude \
--output groceries.krate
Krate hands the request to the agent, then builds, checks, packages, and
verifies exactly as with the built-in path — a broken app is caught, not
shipped. For any other tool, --author-cmd "<your command>"
is the lower-level seam; it receives:
| Variable | Meaning |
|---|---|
KRATE_REQUEST |
|
| The user's request | |
KRATE_APP_NAME |
|
| The generated app name | |
KRATE_APP_DIR |
|
| The folder where the agent writes the app |
Everything after authoring stays the same. Krate builds the result, refuses imports outside the Krate interfaces, packages the app, and verifies its requested access.
The public release can also return output that AI tools and scripts can read:
krate run app.krate --json --auto-grant
The output follows the krate.run.v1
schema.
A .krate
file contains:
- a WebAssembly component;
- the app name and version;
- the access the app requests;
- the reason for each request.
Opening the file does not grant access by itself. Krate creates a session from the user's decision and connects only the approved operations to the computer.
Examples:
fs.read:notes/**
can read only inside thenotes
folder;fs.write:checklist/**
can write only inside thechecklist
folder;- no network request works unless network access was declared and granted;
- a downloaded app receives no extra access because it came from a URL.
Inspect an app without running it:
krate run app.krate --dump-caps
Run it and review each request:
krate run app.krate --prompt
| Capability | Current state |
|---|---|
One .krate file |
|
| Working | |
| Mac, Windows, and Linux execution | Working |
| Desktop windows on all three systems | Working |
| Text input, editing, selection, and local saving | Working |
| File and network capabilities | Working |
| Permission checks before app execution | Working |
Run a .krate file from an HTTPS URL |
|
| Working | |
| Create a supported app from a request | Working |
| Let an external AI command author the app | Working |
| JSON output for agents and scripts | Working |
| Convert an existing native app automatically | Not available yet |
| Public app cloud, discovery, identity, and updates | Planned |
The public CI runs the project on Linux, macOS, and Windows. See CI and the current status for exact evidence.
| macOS | Windows | Linux | |
|---|---|---|---|
Runs .krate apps |
|||
| Yes | Yes | Yes | |
| Opens desktop windows | Yes | Yes | Yes |
| Notes editing and saving | Yes | Yes | Yes |
.krate file registration |
|||
Krate.app |
|||
| Registration script | Registration script | ||
Permission review in v0.1.0-rc4 |
|||
| Native window | Terminal | Terminal |
The current macOS path uses AppKit controls. Windows and Linux use Krate's drawn widget path inside a native window.
Development has already improved the Linux no-terminal permission path, but
that change is not part of v0.1.0-rc4
. Release claims in this README describe the public release unless a section clearly says otherwise.
Krate gives an app no access to the user's files or network by default. It can use only the access approved for the current run.
That boundary is useful, but it does not make every app bug-free or prove that every author is trustworthy.
Krate is pre-alpha:
- use it for testing your own apps and the published examples;
- do not treat it as ready for hostile third-party code;
- expect file formats and interfaces to change before version 1.0;
- report security problems privately through SECURITY.md.
Read the current threat model for technical detail.
- Krate does not convert an existing Swift, Electron, Tauri, or native app.
- The built-in author currently creates a small supported set of applications.
- A coding agent must use the current Krate APIs.
- The public macOS app is not code-signed yet.
- Permission review and desktop polish differ between operating systems.
- Krate Cloud does not exist yet.
- Signing, publisher identity, public discovery, managed updates, and a transparency log are planned work.
These limits are part of the product status, not hidden footnotes.
A browser is the right answer for many applications.
Some useful local apps need desktop windows, local files, keyboard shortcuts, devices, or operating system behavior that a browser cannot provide cleanly. Normal native apps can do those things, but sharing them means packaging for each system. The person opening one also has to trust code they did not write.
Krate is for the space between those two choices.
Krate is written in Rust and uses:
Wasmtimeto execute WebAssembly components;- the WebAssembly Component Model; - WIT interfaces for portable app behavior;
- host adapters for macOS, Windows, and Linux;
- a capability policy that checks every supported host operation.
The portability is how one file works across operating systems. The capability model is how the user controls what that file can reach.
apps/ Sample apps and apps used to test Krate
crates/ Runtime, CLI, policy, adapters, authoring, and SDK code
docs/ Website, book, design records, and technical documentation
Plan/ Current and future implementation plans
scripts/ Build, install, test, evidence, and release tools
test/ Integration fixtures and cross-language tests
wit/ Krate interface definitions
Requirements:
- the Rust toolchain selected by
rust-toolchain.toml
; - Git;
- platform build tools;
cargo-component
when building Krate apps.
git clone https://github.com/incyashraj/krate
cd krate
cargo build --workspace
cargo test --workspace
cargo clippy --all-targets --all-features -- -D warnings
cargo fmt --all -- --check
Build the release CLI:
cargo build --release -p krate-cli
target/release/krate --version
| Start here | Link |
|---|---|
| Plain guide for making an app | |
Try Krate NotesQuickstartVisionRoadmapBuild logStatusThe immediate priority is external use:
- watch new users install, create, open, and share an app;
- repair the points where they get stuck;
- expand the apps an AI agent can author;
- make the permission experience clear on every operating system.
Later work includes:
- tools that help port existing source code to Krate interfaces;
- signing and publisher identity;
- Krate Cloud for publishing, finding, sharing, and updating apps;
- organization policies and audit records;
- more operating systems and device types.
See the full roadmap.
Contributions are welcome across code, documentation, design, examples, and testing.
Start with:
For a larger change, open an issue or discussion before writing the full implementation.
-
Stage: pre-alpha
-
Current public release:
v0.1.0-rc4 -
Company: Krate Labs
-
Maintainer: Yashraj Pardeshi - License: MIT OR Apache-2.0
Krate was previously named Layer36. The rename is complete in the repository, commands, interfaces, and documentation.
Choose either:
Contributions use the same dual license.
Krate builds on work from the Bytecode Alliance, Wasmtime, the Rust community, and the wider WebAssembly community.