# Orca wants to run your WebAssembly app like a desktop app, not a web page

> Orca is a development and runtime environment for portable graphical applications compiled to WebAssembly and run outside the browser, in C, Odin or Zig. Its own disclaimer calls it very much a work in progress with unstable APIs and sparse documentation, and the release tags are named test-release rather than versioned.

**orca-app/orca** — A Wasm environment for cross-platform, sandboxed graphical applications.

- Repository: https://github.com/orca-app/orca
- Website: https://orca-app.dev
- Stars: 647 · Forks: 30
- Language: C
- License: NOASSERTION
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/orca-app-orca

## A runtime that is deliberately not a browser

Orca is described as a development and runtime environment for building and distributing portable graphical applications. The applications can be written in C, Odin or Zig, or in any language that compiles to WebAssembly and has bindings for the Orca SDK, and they run on a custom runtime outside the browser.

The stated goal is to provide the same benefits as web apps, ease of distribution, portability and sandboxing, without the weight of a whole web browser and the complexity brought by the web stack. That framing tells you what Orca is trying to be and, just as usefully, what it is trying not to be. It is not an Electron alternative in the sense of embedding Chromium, and it is not a browser engine with a shell around it. It is a small runtime designed for graphical applications that happen to be compiled to WebAssembly.

The second half of the goal is the more interesting one. Orca is not only a packaging format, it is a development and deployment platform where you interactively build apps in a live, observable environment and share them as easily as sending a URL. That is a different product category from a cross compilation toolchain, and it is the part that is hardest to judge from a README.

The project publishes a website at orca-app.dev, documentation at docs.orca-app.dev, a Discord server, a newsletter, and a GitHub Sponsors page for those who want to fund it monthly. The README also points at an announcement post that explains the goals in more depth than the README does.

## The disclaimer is the most useful paragraph in the README

The first thing in the README is a warning, and it deserves to be quoted in substance rather than summarised away.

It says the project is very much a Work In Progress, and that you should expect bugs, missing and/or incomplete features, unstable APIs and sparse documentation. It goes on to say that some current issues might be a show stopper for you, and to make sure you can build and run the sample apps before jumping in. Then it thanks anyone who tries it anyway and asks for feedback.

That framing should change how you read everything else in the document. When the MVP feature list says you can draw paths, images and text with a 2D vector graphics API, that is a statement about the current build, not a guarantee. When the samples list mentions a ui sample that showcases the UI API and Orca's default UI widgets, that tells you the widget set exists but says nothing about how complete it is. The README tells you the current state is a foundation rather than a finished platform, and that the fastest way to find out whether the foundation is enough for your app is to build the samples.

There is one more line in the contributing section worth noting. It says the design and implementation of Orca is ultimately decided by one person, Marti, and that contributors should take that into account. For a project that wants to be a platform, that is a governance fact a team should price in.

## What the early MVP can actually do

The feature list is short enough to enumerate, and each item tells you what kind of application Orca is aiming at.

Input is first: receiving mouse and keyboard input. Then drawing, in two layers. There is a 2D vector graphics API for paths, images and text, and there is OpenGL ES 3.1 for 2D and 3D graphics, minus a few features such as mapped buffers. Then a UI API with default widgets for building interfaces. And then a capability-based API for reading and writing files, which is the sandbox story: the application asks for capabilities rather than being handed the whole filesystem.

The samples directory matches that list one for one, and reading the sample names is the fastest way to understand the API surface. The breakout sample is a small breakout game using the vector graphics API. The clock sample is a simple clock showing vector graphics and the time API. The triangle sample draws a spinning triangle with the GLES API. The fluid sample is a fluid simulation with a more complex GLES setup. The ui sample shows the UI API and the default widgets. There is also a microui sample in the repository listing.

The combination of a vector graphics API, a GLES API, a widget set and a capability based file API is a coherent target: a small native-feeling application, not a document, not a terminal, and not a browser. The absence of a text rendering or layout story beyond widgets, and the absence of any web content, tells you where the boundaries are.

## Installing the toolchain, and the clang trap on Mac

Installing Orca means installing the command line tools and the SDK, and the README is specific about the host requirements. You need Windows 10 or later, or a Mac 14 or later, and Linux is not yet supported.

The compiler requirement is where people lose an afternoon. You need clang 11.0 or newer, but the version of clang that the Visual Studio installer puts on Windows may not support WebAssembly, so the README advises installing clang from the LLVM release page instead. On the Mac, Apple's built in clang does not support WebAssembly, and the recommended path is to install LLVM through Homebrew with brew install llvm.

There is a second layer, and it is the part most guides would skip. When targeting WebAssembly, clang relies on builtins found in libclang_rt.builtins-wasm32, and most clang distributions do not ship that file. The README tells you how to check, by running clang --target=wasm32 -print-libgcc-file-name, and where to get it if it is missing, from the wasi-sdk releases.

The Orca tools themselves are downloaded as an archive from the repository's releases page and extracted wherever you want them installed. The archives are orca-windows.tar.gz, orca-mac-arm64.tar.gz and orca-mac-x64.tar.gz, each extracted with tar -xzf. On Windows you add the extracted orca folder to your PATH; on the Mac the executable lives inside the Orca.app bundle, so you add the path ending in Orca.app/Contents/MacOS/orca to your PATH. The README links to instructions for editing PATH on both platforms.

Then you check the install with:

```
orca version
```

## Building a sample and running the result

The fastest way to evaluate Orca is to build one of the samples, because the README explicitly recommends it as the test of whether the project works for you.

You change into the sample's directory and run its build script. For the breakout sample that is:

```
cd samples/breakout

# Windows
build.bat

# Mac
./build.sh
```

On Windows this creates a Breakout directory in samples/breakout, and the app is launched with orca run breakout.orca. The .orca extension is the bundle format, so that command line is a small preview of how Orca thinks about distribution: an application is a file you can run, not an installed program with a registry entry and a shortcut.

For your own application the process is two steps, and the README is precise about them. First you compile your code to a WebAssembly module, in any language that has bindings to the Orca APIs. Second you bundle that module and any additional resources such as fonts and images into an Orca image or a standalone executable, using the Orca command line tools.

The resource bundling step is the part with the practical weight. A graphical application needs fonts and images, and those have to travel with the WebAssembly module, which is exactly the kind of thing a web deployment solves with URLs and a server and that a native runtime has to solve with a package format. Orca's answer is a bundle, and the image or executable is that bundle.

The Quick Start Guide in the documentation directory walks through building a simple application, and the online documentation lists the API functions grouped by topic.

## Build from source, and what the repository holds

Building Orca itself is documented separately, in the building page of the documentation, and the repository layout is the evidence of what the project is made of.

The build system is Zig. There is a build.zig and a build.zig.zon at the root, which is how a project of this kind bootstraps its own toolchain rather than depending on a system package manager. The source is in src/, with tests/ beside it and sketches/ for experiments, resources/ for shared assets, scripts/ for tooling, and doc/ for the documentation tree, which includes a mkdocs setup under doc/mkdocs/docs. There is also a .clang-format, so the C sources are formatted with clang format even though the build is driven by Zig.

The primary language for the repository is recorded as C, which matches the SDK and runtime side of the project rather than the application side, since applications can be written in C, Odin or Zig.

The release history is the last thing to look at, and it is unusual. The recent releases are named test-release-996c93e813 from 2026-03-19, test-release-e04ba55b78 from 2025-07-09 and test-release-3018076351 from 2025-04-21. Those are not version numbers, they are artifacts produced by a test pipeline, which tells you that automated release tagging is still part of the workflow rather than a curated versioning scheme. The last push was on 2026-10-19, so the work is current even though the release naming is not.

The licence is one that GitHub could not classify, and the repository carries a LICENSE.txt file rather than a standard licence name, so read that file directly before you build anything on top of this.

## The honest alternative is still the browser

For most teams today, the realistic alternative to Orca is not another native runtime. It is shipping the application as a web application, because the web platform already solves distribution, portability and sandboxing, and it solves them today rather than in a future MVP.

The difference in approach is exactly what Orca's README says it wants. A web application runs inside a browser, which means it inherits the browser's weight, its security model, its plugin ecosystem and its constraints, and it means your application is delivered as code and resources fetched over the network. Orca compiles the same WebAssembly modules and runs them in a runtime that exists only to host them, so you get a small runtime, a sandbox built on capabilities, and a bundle you can hand someone as a file.

The other alternative, if you want native speed and no web stack but do not want to write a runtime, is to write a normal native application and accept that it is no longer portable and no longer a single file. That trade is the one Orca is trying to make attractive, and today Orca is a very early version of that idea.

So the decision comes down to appetite for a moving platform. If your requirement is to ship a graphical application to end users this quarter, a web application or a native build will serve you better. If your requirement is to influence and use a runtime where a graphical app is a sandboxed, portable, shareable bundle compiled from one language-agnostic binary format, Orca is the project to watch and to give feedback to, and the disclaimer tells you that is exactly what it wants from you.

## Conclusion

Adopt Orca only if you are experimenting with a WebAssembly application runtime, you can target Windows 10 or later or a Mac 14 or later, and you are prepared to write against an API that the project itself calls unstable. Do not adopt it for production delivery today, since the README lists missing features, unstable APIs and sparse documentation, and warns that some current issues might be a show stopper. Before you invest, build the breakout sample on your machine, check that clang with the wasm32 builtins is available, and read the Quick Start Guide rather than the README alone.

## FAQ

### What is Orca and what can it build?

Orca is a development and runtime environment for portable graphical applications compiled to WebAssembly and run outside the browser, in C, Odin or Zig. In this early MVP you can receive mouse and keyboard input, draw with a 2D vector graphics API and OpenGL ES 3.1, build interfaces with the UI API and default widgets, and read and write files through a capability-based API.

### How do I install the Orca command line tools and SDK?

Download the archive for your platform from the repository's releases page, orca-windows.tar.gz, orca-mac-arm64.tar.gz or orca-mac-x64.tar.gz, extract it with tar -xzf, and add the orca executable directory to your PATH. On the Mac the executable is inside the Orca.app bundle. Then verify the install with the orca version command.

### Which platforms does Orca support?

Windows 10 or later and Mac 14 or later are the supported hosts, and Linux is not yet supported. You also need clang 11.0 or newer with WebAssembly support, and the clang runtime builtins for wasm32, which most clang distributions do not ship.

### How do I package an Orca application?

In two steps: compile your code to a WebAssembly module, then bundle the module and any extra resources such as fonts and images into an Orca image or a standalone executable with the Orca command line tools. The bundled app is run with orca run, for example orca run breakout.orca.

## Sources

- [Issues](https://github.com/orca-app/orca/issues)
- [orca-app/orca on GitHub](https://github.com/orca-app/orca)
- [Project website](https://orca-app.dev)
- [README](https://github.com/orca-app/orca/blob/main/README.md)
- [Releases](https://github.com/orca-app/orca/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/orca-app-orca