Skip to content
Back to search

krate

Make and send apps like pictures: one .krate file that opens from a link in any browser, phones included, and runs natively on macOS, Windows and Linux. Open-source Rust runtime on Wasmtime, with permissions the person approves.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/incyashraj--krate/badge.svg)](/listings/incyashraj--krate)

HTML

<a href="/listings/incyashraj--krate"><img src="/api/listings/incyashraj--krate/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 518 lines · 3 findings marked
  1. <p align="center">
  2. <img src="docs/landing/krate-logo.png" width="112" alt="Krate logo">
  3. </p>
  4. <h1 align="center">Krate</h1>
  5. <p align="center">
  6. <strong>Make and send apps like pictures.</strong>
  7. </p>
  8. <p align="center">
  9. Describe an app and Krate makes it, or write it yourself in Rust. It is one <code>.krate</code> file.<br>
  10. Send it as a link and it opens in any browser, phones included, with nothing to install.<br>
  11. On macOS, Windows and Linux the same file runs natively. Every app is sandboxed: it reaches only<br>
  12. what it asks for and the person allows. Open source, built on Wasmtime.
  13. </p>
  14. <p align="center">
  15. <a href="https://github.com/incyashraj/krate/actions/workflows/ci.yml">
  16. <img src="https://github.com/incyashraj/krate/actions/workflows/ci.yml/badge.svg" alt="CI status">
  17. </a>
  18. <a href="https://github.com/incyashraj/krate/releases/latest">
  19. <img src="https://img.shields.io/github/v/release/incyashraj/krate" alt="Latest stable release">
  20. </a>
  21. <a href="LICENSE-MIT">
  22. <img src="https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-2563eb" alt="MIT or Apache 2.0 license">
  23. </a>
  24. <a href="https://discord.gg/XaEegAxDCb">
  25. <img src="https://img.shields.io/badge/Discord-join%20the%20community-5865F2?logo=discord&logoColor=white" alt="Join the Krate Discord">
  26. </a>
  27. </p>
  28. <p align="center">
  29. <a href="https://github.com/incyashraj/krate-app-template"><b>Start from the template</b></a>
  30. ·
  31. <a href="https://krate.tech/docs/quickstart.html">Quickstart</a>
  32. ·
  33. <a href="https://krate.tech/docs/">Docs</a>
  34. ·
  35. <a href="https://github.com/incyashraj/krate/releases">Releases</a>
  36. ·
  37. <a href="https://github.com/incyashraj/krate/discussions">Discussions</a>
  38. </p>
  39. <table align="center">
  40. <tr>
  41. <td align="center"><img src="docs/landing/showcase/orbit.webp" width="280" alt="Orbit, a live network globe"><br><sub><b>Orbit</b> · network globe</sub></td>
  42. <td align="center"><img src="docs/landing/showcase/aurora.webp" width="280" alt="Aurora, northern lights computed per pixel"><br><sub><b>Aurora</b> · simulation</sub></td>
  43. </tr>
  44. <tr>
  45. <td align="center"><img src="docs/landing/showcase/player.webp" width="280" alt="Player, a music player with a live spectrum"><br><sub><b>Player</b> · music player</sub></td>
  46. <td align="center"><img src="docs/landing/showcase/editor.webp" width="280" alt="Editor, a code editor with tree, tabs and minimap"><br><sub><b>Editor</b> · code editor</sub></td>
  47. </tr>
  48. </table>
  49. <p align="center"><sub>Each is one <code>.krate</code> file built with Krate, with its source in <a href="apps/">apps/</a>. See them running at <a href="https://krate.tech/#made">krate.tech</a>.</sub></p>
  50. ## In numbers
  51. The same 50,000-line notes workload on the same Apple M4 Mac, against
  52. MarkText 0.17.1, an Electron editor. Both ARM64, measured 25 August 2026.
  53. | | MarkText (Electron) | Krate |
  54. |---|---:|---:|
  55. | Memory with the document open | 2,299.4 MiB across four processes | **178.5 MiB, one process** |
  56. | Warm open to a visible window | 611.5 ms, median of 10 | **237.1 ms, median of 10** |
  57. | The app on disk | 284.6 MiB installed | **36.6 KiB**, plus the 88.6 MiB runtime installed once for every app |
  58. That is one workload, and other apps will measure differently. The
  59. [benchmark kit](evidence/benchmarks/marktext-vs-krate/README.md) and
  60. [this run's analysis](evidence/benchmarks/marktext-vs-krate/runs/20260825T085644Z/analysis.md)
  61. say how it was measured.
  62. Also in [apps/](apps/): id Software's 1993 [Doom](apps/krate-doom), running
  63. under Krate as one 2.8 MB `.krate` that asks for three permissions: a
  64. window, printing its start-up lines, and reading its arguments. Runtimes
  65. ship for macOS (Apple silicon, Intel), Windows (x64, ARM64) and Linux
  66. (x86_64, arm64).
  67. ## Start here
  68. **Send an app as a link.** Publish any `.krate` and send the link:
  69. ```sh
  70. krate publish my-app.krate
  71. ```
  72. Whoever taps it sees the app open in their browser, on a phone, a tablet
  73. or a computer, with nothing to install. Publishing it again is the app's
  74. next version: the same link opens the update. A few abilities (working in a
  75. folder on the computer, Bluetooth) need Krate on a computer, and the app
  76. says so in words when it asks for one. Or make one in [Krate Studio](https://krate.tech/studio/)
  77. and press Share.
  78. **Build your own app.** Press **Use this template** on
  79. [krate-app-template](https://github.com/incyashraj/krate-app-template).
  80. It is a small working app (a counter that keeps its value) whose CI builds
  81. one `.krate` and then opens that same file on Linux, macOS and Windows.
  82. To build it on your machine:
  83. ```sh
  84. rustup target add wasm32-wasip1
  85. curl -fsSL https://krate.tech/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 102 on GitHub
  86. krate check-app .
  87. ```
  88. `check-app` builds the app, confirms it imports only Krate's interfaces,
  89. runs it once, and tells you which stage failed and how to fix it. In CI,
  90. [setup-krate](https://github.com/incyashraj/setup-krate) installs Krate on
  91. any GitHub runner.
  92. **Open an app someone sent you.** A link opens in your browser. To run
  93. `.krate` files natively on a computer, install Krate once:
  94. ```sh
  95. curl -fsSL https://krate.tech/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 115 on GitHub
  96. ```
  97. On Windows, use `irm https://krate.tech/install.ps1 | iex`. Read the
  98. [Unix script](scripts/install.sh) or [PowerShell script](scripts/install.ps1)
  99. first if you prefer, or download an archive from
  100. [Releases](https://github.com/incyashraj/krate/releases/latest).
  101. Then try [Chart](https://raw.githubusercontent.com/incyashraj/krate/c46d29500f2b894c89285b04e1b5e2f75184e972/evidence/ported/chart.krate),
  102. a small rainfall chart ([source](https://github.com/incyashraj/krate/tree/c46d29500f2b894c89285b04e1b5e2f75184e972/apps/krate-chart),
  103. [checksum](https://krate.tech/docs/quickstart.html#try-the-chart-sample)):
  104. ```sh
  105. CHART=https://raw.githubusercontent.com/incyashraj/krate/c46d29500f2b894c89285b04e1b5e2f75184e972/evidence/ported/chart.krate
  106. krate run "$CHART" --dump-caps
  107. krate run "$CHART" --prompt
  108. ```
  109. `--dump-caps` lists what the app asks for without running it. Chart asks
  110. for a window and nothing on your files or the network. On Linux X11 you may
  111. need [one system library](docs/build.md#running-an-app-on-linux-without-building-anything).
  112. ## Build your app
  113. | Your starting point | Next step |
  114. | --- | --- |
  115. | Start fresh in Rust | [krate-app-template](https://github.com/incyashraj/krate-app-template), then the [Rust SDK](crates/bindings-rust/README.md) |
  116. | Bring an existing project | [Porting guide](https://krate.tech/docs/porting.html); start with the read-only `krate port ./my-project` scan |
  117. | Build with AI | [Krate Studio](https://krate.tech/studio/), or `krate create` with the coding agent you already use |
  118. | Judge the design | [Portable format](https://krate.tech/portable-desktop-app-format.html), [distribution comparison](https://krate.tech/desktop-app-distribution.html) and [current limits](https://krate.tech/docs/limits.html) |
  119. To build with AI from the terminal, you need the Rust and component tools
  120. and an installed, signed-in coding agent. Its subscription or API costs are
  121. your own:
  122. ```sh
  123. krate doctor
  124. krate create "a regex tester with a pattern box and live matches" --agent claude --output regex.krate
  125. krate run regex.krate --dump-caps
  126. ```
  127. `krate check-app` checks the build, the imports and a first run. Use the app
  128. yourself and try it on each system you plan to support before you send it.
  129. Have an app in mind? Tell us what it does and which systems it needs in the
  130. [welcome discussion](https://github.com/incyashraj/krate/discussions/1).
  131. ## Nothing installed? Start in the browser
  132. [krate.tech/app](https://krate.tech/app/) is Krate Studio in a tab. Sign in
  133. with GitHub, Google or an email link, describe
  134. the app you want and **Krate AI** writes it, builds it on our machines and
  135. hands back a `.krate` you can download and run. No install, no toolchain, no
  136. API key of your own.
  137. Your first app is on us, and so is your first change to it. After that,
  138. Krate Studio on your own machine is free and unlimited when you point it at
  139. an AI you already have (Claude, Codex, Gemini, or an API key you hold). The
  140. session follows your account, so anything you start in the browser opens on
  141. the desktop ready to edit.
  142. ## Why a file
  143. <p align="center">
  144. <img src="docs/landing/og-v5.png" width="760" alt="Krate: make and send apps like pictures. Opens from a link in any browser, phones included, and natively on Mac, Windows and Linux">
  145. </p>
  146. Cross-platform frameworks can share source while still producing separate
  147. application packages for each platform. Krate moves the platform-specific
  148. part into a shared runtime and makes the application artifact portable.
  149. 1. The app and the access it asks for go into one `.krate` file.
  150. 2. That same file opens on Mac, Windows, and Linux. The bytes do not change.
  151. 3. Krate shows the person what it wants before it runs.
  152. 4. Host operations are checked against the session's capabilities.
  153. A Krate app is a WebAssembly component compiled from ordinary Rust. It
  154. carries no browser engine or per-app native runtime. Package size depends on
  155. code, source, dependencies and assets; there is no universal size promise.
  156. The goal is to make `.krate` a standard way developers ship software.
  157. Today, that depends on the app fitting Krate's supported interfaces.
  158. ## Krate Studio
  159. <p align="center">
  160. <a href="https://krate.tech/">
  161. <img src="docs/landing/readme/studio-build.gif" width="860" alt="A real build in Krate Studio: one sentence, a plan, the AI writing and checking the app, then the finished colour palette app">
  162. </a>
  163. <br>
  164. <sub>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.</sub>
  165. </p>
  166. <p align="center">
  167. <img src="docs/landing/readme/studio-session.png" width="900" alt="Krate Studio: the conversation on the left, the finished app in the Preview panel on the right, with Files, Code and Details beside it">
  168. </p>
  169. A session is a conversation beside a panel. On the left, what you asked,
  170. the plan, and the AI's working (folded into one live line you can open).
  171. On the right, the app itself: **Preview** runs it, **Files** lists what is
  172. inside the `.krate`, **Code** shows the Rust it was built from, **Details**
  173. says what it may use. **Share** gives a link, the file, or a one-click
  174. installer for someone new to Krate.
  175. Studio runs the same engine the CLI does: build, import-check, run and
  176. pack, with the engine's real output on screen, not a summary of it. It uses
  177. the coding AI you already have installed and pay for, and stays out of the
  178. way if you would rather write the code yourself. Every `.krate` carries its
  179. own source, so a build you shipped a year ago opens as a project you can
  180. edit.
  181. It runs in two places, and they are the same interface rather than two
  182. lookalikes:
  183. - **In a browser**, at [krate.tech/app](https://krate.tech/app/). Krate AI
  184. does the writing and the build happens on our machines. Nothing to
  185. install, and your first app and first change are free.
  186. - **On your machine**, from [krate.tech/download](https://krate.tech/download/).
  187. Signed `.dmg` on macOS, installer on Windows (unsigned for now, so
  188. SmartScreen asks once), AppImage on Linux. Free and unlimited with your
  189. own AI.
  190. Sessions live on your account, so an app you start in the browser opens on
  191. the desktop with its conversation intact and editable.
  192. ## For a team
  193. [krate.tech/orgs](https://krate.tech/orgs/) gives a company its own place
  194. on Krate. Name the organisation, release its first app (Team Notes,
  195. Expenses, Stock List, or a `.krate` you made) and invite your team by
  196. email, all from one page. A developer sends an app, a reviewer approves its
  197. exact bytes, and only your people can open it: a copied link alone opens
  198. nothing. The apps' team data and the credentials for your company's APIs
  199. are encrypted on members' computers, so Krate's hub stores them without
  200. being able to read them.
  201. For IT: company sign-in with OpenID Connect or SAML 2.0, people and groups
  202. kept in step by SCIM, a policy that says which apps may open on company
  203. computers, and an audit of every approval. Read
  204. [Organisations](https://krate.tech/docs/organisations.html) and
  205. [Running Krate in an organisation](https://krate.tech/docs/running-in-an-organisation.html).
  206. ## What it costs
  207. Nothing, right now. The player is MIT and Apache licensed and always will
  208. be. The CLI and Krate Studio on your own machine are free and uncapped,
  209. and we will say so long before that changes.
  210. The one thing with a limit is the inference we pay for. Krate AI in the
  211. browser writes your first app and your first change to it on us; after
  212. that, making is unlimited on your own machine with an AI you already have.
  213. If you point Krate at your own coding AI, that stays your subscription and
  214. Krate never holds its keys.
  215. ## The permission wall
  216. A `.krate` holds a WebAssembly component, the app's name, the access it
  217. requests, and a reason for each request. Opening the file grants nothing on
  218. its own; Krate connects only the operations the person approved. Look
  219. inside any app without running it:
  220. ```bash
  221. krate run app.krate --dump-caps
  222. ```
  223. - `fs.read:notes/**` reads only inside the `notes` folder;
  224. - `store.kv` / `store.sql` give an app private storage, so remembering
  225. things needs no access to your folders at all;
  226. - no network call works unless network access was declared and granted, and
  227. a redirect to a host you did not allow is not followed;
  228. - an app downloaded from a URL gets no extra access for having come from one;
  229. - the camera, the microphone, speech and sound sit behind the same wall, so
  230. an app that wants to see or hear you has to say so first;
  231. - a file you pick or drag onto a window is handed over as a name and a
  232. token, never a path, so the app opens that one file and cannot walk to its
  233. folder or come back for it on a later run;
  234. - `store.shared` and `net.ws` are the multiplayer pair: a bucket two
  235. machines share through an invite code, and a live two-way connection.
  236. The strong version of the claim is mechanical, not a promise: these apps
  237. import **zero** `wasi:*` interfaces. There is no ambient access to leak
  238. because the door was never built into the app. Check any app yourself with
  239. `wasm-tools component wit`.
  240. ---
  241. ## Work on it
  242. Everything above is what Krate does. Everything below is the machinery:
  243. the player, the `.krate` format, and `krate check-app` live in this
  244. repository; Krate Studio and the hub are the product layer (`studio/`
  245. and `cloud/`).
  246. ## A terminal or your own AI tools
  247. Studio is one front end for the engine, not the only one. Whichever you
  248. pick, every path ends at the same `.krate` file:
  249. - **Claude Code plugin**: in Claude Code, run
  250. `/plugin install krate --marketplace incyashraj/krate-claude-plugin` (or,
  251. in a terminal, `claude plugin marketplace add incyashraj/krate-claude-plugin`
  252. and then `claude plugin install krate@krate`). It teaches Claude to
  253. make, check, package and publish Krate apps with Krate's own commands.
  254. Install Krate itself first. Source:
  255. [krate-claude-plugin](https://github.com/incyashraj/krate-claude-plugin).
  256. - **MCP**: `krate mcp` is a server Claude Desktop or Cursor can call; add
  257. `{"mcpServers": {"krate": {"command": "krate", "args": ["mcp"]}}}` to the
  258. app's MCP config and ask for the app in chat. Full setup:
  259. [docs/mcp-setup.md](docs/mcp-setup.md).
  260. - **Krate Mode**: one paste-in prompt that teaches any AI chat to write
  261. correct Krate code, generated from the real interface definitions.
  262. `krate krate-mode` prints it;
  263. [read it online](https://krate.tech/docs/pages/krate-mode.html).
  264. - **One word**: `krate` asks what you want and builds it. In one line:
  265. `krate create "a habit tracker" --output habit.krate --agent claude`.
  266. Five agents are supported (`claude`, `codex`, `gemini`, `copilot`,
  267. `grok`); `krate ai` says which are ready, and `--author-cmd` is the seam
  268. for anything else.
  269. Ask for something a sandboxed app cannot be, like "download my email", and
  270. `krate create` refuses in about a second with the reason and a suggestion,
  271. instead of spending five minutes building something convincing that could
  272. never work.
  273. ## `krate check-app`: the oracle behind AI authoring
  274. An AI writing code needs a truthful, fast answer to "is this actually
  275. correct?" `check-app` runs nine stages and prints one verdict; because the
  276. failure text names the fix, an agent can loop on it without a human in the
  277. middle.
  278. | Stage | Exit | What it proves |
  279. | --- | --- | --- |
  280. | layout | 10 | The directory has the files an app needs |
  281. | manifest | 11 | The manifest is valid |
  282. | build | 12 | It compiles, with the right toolchain |
  283. | imports | 13 | It imports only `krate:*`, no `wasi:*` leak |
  284. | run | 14 | It actually runs, headless |
  285. | shoot | 15 | A GUI app paints a real frame |
  286. | usability | 16 | Driven the way a person would: it stays open, follows a resize, answers a press |
  287. | screens | 17 | It fits a phone, a tablet and a desktop window (from 0.5.5) |
  288. | 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) |
  289. `--json` gives the same verdict as a machine-readable object; `--shoot
  290. frame.png` writes the app's first frame to a PNG so output can be looked at
  291. rather than guessed about.
  292. ## New in 0.6
  293. - **Make an app in your Claude chat.** Add Krate to Claude as a connector
  294. (`https://hub.krate.tech/mcp`) and ask for an app in plain words: Claude
  295. writes it, Krate builds and checks it, and you get a link that opens on any
  296. phone or computer, with nothing to install. If a build fails, Claude gets
  297. Krate's own words and fixes it. In Claude Code, the
  298. [Krate plugin](https://github.com/incyashraj/krate-claude-plugin) adds the
  299. same connector. [How it works](https://krate.tech/docs/pages/make-an-app-with-claude.html).
  300. - **Apps know the person's local time.** `krate::locale::today()` and
  301. `local_now()` give the local date and time as numbers, daylight saving
  302. included, on desktop and in a browser tab.
  303. - **Apps reach the factory floor.** Serial ports (`device.serial`), label and
  304. receipt printers the person picks once (`device.printer`, raw ZPL, EPL or
  305. ESC/POS), USB devices of a model the app names (`krate:usb`), spreadsheets
  306. (`.xlsx`, `.ods`, `.csv`), and serving on the computer or the local
  307. network, announced by name (`net.listen:<port>`), each behind the
  308. permission wall.
  309. - **Krate Studio's workbench.** Beside the code: the app on a phone, a
  310. tablet and a desktop at once; every permission as a switch, to see what a
  311. person who says no sees; Krate's checks as cards; and a pretend Zebra
  312. label printer and (on Mac and Linux) bench scale, so a label app is built
  313. with no printer on the desk.
  314. - **Every app you make is signed as you, from its first file.** One
  315. publisher key per person per computer, made with no account and no
  316. question. Your app keeps its data through every rebuild, and no other app
  317. claiming its id can reach it.
  318. - **A new key without losing anything.** `krate identity --new-key` hands
  319. over from your old key to a new one, signed by both; each app moves its
  320. data across the first time it opens. `--report-compromised` tells Krate
  321. Cloud first: releases the old key signed since a date are blocked, and
  322. each app goes back to its last safe version.
  323. - **Changing an app with AI is a transaction.** The app you have is
  324. replaced only by a build that passed every check, and never over a file
  325. something else changed while the AI worked; that change is kept beside
  326. it instead.
  327. - **Installed apps are themselves.** Finder, Spotlight, Launchpad and the
  328. Windows Start menu show the app's own name, and a Start menu entry opens
  329. with no console window.
  330. - **Krate Cloud** keeps an update with its publisher (another key is
  331. refused unless the old one handed over), treats a re-packed release as
  332. the version it already is, ranks gallery search by relevance with the
  333. publisher's verified identity shown on every result (no placement is
  334. sold), and sends a blocked update's link back to the last safe version.
  335. ## Where things stand
  336. One `.krate` runs on Mac, Windows, and Linux, GPU-rendered with a CPU
  337. fallback; files, network, storage, and clipboard sit behind the permission
  338. wall; apps run from a file or straight from an HTTPS URL; publishing a
  339. link works from Studio, `krate publish`, or
  340. [krate.tech/publish](https://krate.tech/publish). Exact evidence:
  341. [STATUS.md](STATUS.md).
  342. Known limits, stated plainly:
  343. - Apps use Krate's interfaces. Existing native binaries, Electron apps and
  344. Tauri apps need a port, not a file-extension change. Check
  345. [capability limits](https://krate.tech/docs/limits.html) and the
  346. [porting guide](https://krate.tech/docs/porting.html).
  347. - Windows and Linux studio builds are unsigned for now; macOS is signed and
  348. notarised by Apple.
  349. - An AI has to write against the current Krate APIs, which are still changing.
  350. - Permission review and desktop polish differ between operating systems.
  351. - File formats and interfaces will change before 1.0.
  352. - This is a young product, not a frozen API. Use it for your own apps and
  353. the published examples, not as a shield against hostile third-party code.
  354. ## Build from source
  355. ```bash
  356. git clone https://github.com/incyashraj/krate
  357. cd krate
  358. cargo build --workspace && cargo test --workspace
  359. ```
  360. The workspace has over 2,300 Rust tests. You need the Rust toolchain named in
  361. `rust-toolchain.toml` and `cargo-component`; check your machine with
  362. `krate doctor`. Platform packages, the two Windows traps, and the
  363. one-package Linux receiver note live in [docs/build.md](docs/build.md).
  364. ## Repository map
  365. ```text
  366. apps/ Sample apps and apps used to test Krate
  367. cloud/ The hub (hub.krate.tech) and the build service behind Studio in a browser
  368. crates/ Runtime, CLI, policy, desktop/browser/phone adapters, MCP server, authoring, SDK
  369. docs/ Website, book, design records, and technical documentation
  370. evidence/ Measurements, claim records and release evidence behind the numbers above
  371. scripts/ Build, install, test, evidence, and release tools
  372. studio/ Krate Studio, the desktop app
  373. test/ Integration fixtures and cross-language tests
  374. wit/ Krate interface definitions
  375. ```
  376. ## Documentation
  377. | Start here | Link |
  378. | --- | --- |
  379. | Connect Krate to Claude Desktop or Cursor | [docs/mcp-setup.md](docs/mcp-setup.md) |
  380. | The paste-in prompt for any AI chat | [Krate Mode](https://krate.tech/docs/pages/krate-mode.html) |
  381. | Plain guide for making an app | [Make an app with AI](https://krate.tech/docs/pages/make-an-app-with-ai.html) |
  382. | Developer quickstart | [Quickstart](https://krate.tech/docs/quickstart.html) |
  383. | Private apps for a company | [Organisations](https://krate.tech/docs/organisations.html) |
  384. | Bring an app you already have | [Porting guide](https://krate.tech/docs/porting.html) |
  385. | Build from source | [docs/build.md](docs/build.md) |
  386. | Exact current evidence | [Status](STATUS.md) |
  387. ## Contributing
  388. Contributions are welcome across code, documentation, design, examples, and
  389. testing. Start with [CONTRIBUTING.md](CONTRIBUTING.md), then
  390. [good first issues](https://github.com/incyashraj/krate/labels/good%20first%20issue)
  391. and [Discussions](https://github.com/incyashraj/krate/discussions). For a
  392. larger change, open an issue before writing the full implementation.
  393. Everyone is held to the [Code of Conduct](CODE_OF_CONDUCT.md).
  394. Questions, ideas, or something you made? Come say hi on the
  395. [Krate Discord](https://discord.gg/XaEegAxDCb), where people share what they make and help each other.
  396. ## What Krate counts
  397. A random id made on your machine, the Krate version, the OS name, one of
  398. `install` / `make` / `open` / `publish`, whether an AI wrote the app, and
  399. whether it worked; when an app does not open, one word for why from a fixed
  400. list (`refused`, `not-found`, `bad-bundle` and so on). Never: app names, prompts, paths, or anything about you.
  401. `krate telemetry off` turns it off (`DO_NOT_TRACK=1` is honoured too), and
  402. it says so on first run rather than hiding here.
  403. ## Project status
  404. - Stage: public beta, works end to end, API not yet frozen
  405. - Current release: [the latest on the releases page](https://github.com/incyashraj/krate/releases/latest)
  406. - Company: Krate Labs
  407. - Maintainer: [Yashraj Pardeshi](https://github.com/incyashraj)
  408. - License: MIT OR Apache-2.0 for the player, format and CLI; BSL 1.1 for Studio and the hub ([details](#license))
  409. ## License
  410. Open core, split by what each piece is for:
  411. | Piece | License |
  412. | --- | --- |
  413. | Player, `.krate` format, CLI, runtime: everything a receiver trusts | [MIT](LICENSE-MIT) OR [Apache 2.0](LICENSE-APACHE) |
  414. | Krate Studio (`studio/`) and the hub worker (`cloud/worker/`) | [Business Source License 1.1](studio/LICENSE), converts to Apache 2.0 in 2030 |
  415. The BSL lets you read, build, and use Studio; it stops a competing hosted
  416. Studio. Versions published before the split remain under their original
  417. MIT OR Apache terms. Contributions to the player use the dual license.
  418. ## Acknowledgements
  419. Krate builds on work from the
  420. [Bytecode Alliance](https://bytecodealliance.org/),
  421. [Wasmtime](https://wasmtime.dev/), the Rust community, and the wider
  422. WebAssembly community.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.