How engineering and teams
share one platform.
Engineering provides the shared capabilities and production boundary. Each team builds and ships an app of its own.
The app-store model,
inside your company.
AppOS is a shell that runs apps behind one layout. The shell owns the page and the data. An app is a WebAssembly component with a manifest describing its identity, owner, group and granted capabilities.
Teams agree what an app needs, then build against the platform’s contract. Engineering can improve the platform without becoming the owner of every team’s source code.
The app team owns
The problem, workflow, content, design and implementation. Teams decide whether their app creates value.
The platform team owns
Shared capabilities, data access, integrity rules, policy, runtime limits and production operations.
New business capabilities still need engineering. An app cannot invent access to the company’s systems: the platform has to provide it.
Two permissions.
One allowed call.
The manifest says what an app may do. The company’s policy says which people may make it do that. A call goes through only if both allow it.
App permission
Does this app have kv-write?
User permission
May this person use kv-write in this app?
People sign in through OIDC, a proxy or a sign-in plugin. One policy file says who may use which app, and who is an admin.
Capabilities that touch a business system should enforce its integrity rules in the platform. A useful contract is narrower than “do anything to the database.”
A fresh sandbox
for each request.
Wasmtime runs the compiled component. A request gets a fresh instance with no filesystem, arbitrary network access or inherited environment. The app reaches the outside through permitted host functions.
- CPU fuelAn instruction budget stops a request that does too much work.
- MemoryThe platform bounds memory and table allocations.
- TimeA request deadline includes time spent waiting in host calls.
- I/OReads and writes consume a per-request budget.
- Atomic writesWrites commit when execution succeeds. A failed request discards its pending writes; conflicting reads can cause a retry.
A sandbox confines what code can do. It does not prove that a business decision, a price or a message is correct. Teams remain responsible for that outcome.
Hardening an app
before it goes live.
Hardening means checking an app before it goes live and fixing what the check finds. appos review sets up appfuzz, one way to automate the check, which runs the compiled app against a simulated shell. The review starts from the capabilities, budgets, local data and example requests captured during development.
It can uncover crashes, wasteful calls and unsafe behaviour. Review is evidence from the requests explored, rather than a proof that an app is harmless.
On deployment, AppOS validates the bundle and manifest, checks imports against granted capabilities and runs the app’s initialisation. The submitted unit is an app.zip containing the manifest, component and optional icon.
Available today: run appos review and the appfuzz command it prints. Automatic fuzz review as a mandatory gate on every deploy is a future integration; the current deployment path does not invoke appfuzz.
Every app has an owner,
a history and an off switch.
The app’s manifest names its owner and group. The admin console shows what runs, what it may do, its versions and how requests behave. Events and failures have a record.
- Make an earlier immutable version live.
- Automatically roll back a live version that repeatedly fails.
- Hold new deploys after an automatic rollback until an admin intervenes.
- Set request limits, stop an app, freeze deploys or stop all apps.
When an app’s creator leaves, the company can see it, arrange a handover or stop it. That lifecycle is an organisational responsibility supported by the inventory and controls.
Gardening is this regular care of the live apps. Besides failures and handovers, it covers their dependencies: appos audit lists the live apps that use a crate with a known vulnerability, with their owners. It checks Rust apps; TypeScript, Java and Zig apps are not checked yet.
Providing an approved shipping path helps prevent shadow apps. AppOS does not claim to discover or block apps deployed outside the platform.
Teams choose the language
and the design.
Rust, TypeScript, Zig and Java build paths are present in the project. TypeScript uses scriptc; Java uses TeaVM. All produce components that meet the same AppOS contract.
The scaffolds demonstrate one app structure. Teams can change it: their modules, templates, file layout and internal architecture are their choice. Engineering does not need to adopt each app’s implementation into its own repository.
Language independence means compatible WebAssembly components share a runtime boundary. It does not mean an arbitrary existing framework, package or application can run unchanged. Dependencies must work within the available contract and sandbox.
What works today
and what comes next.
App bundles, capability checks, sign-in, user policy, tokens for the platform API, request isolation, resource limits, storage, versions, ownership, operational controls, a review command for hardening and appos audit for gardening Rust apps are implemented in public main. Inspect the source and validate your production setup before adoption.
Automatic hardening at deployment
Connect appfuzz to the deployment process so a review result can gate a submission. Today, teams can run the review command as part of their own workflow.
Product details are based on the AppOS checkout. Read the source documentation ↗ · Read the architectural vision ↗
YOUR FIRST APPStart small. Make room for more.
Start with one idea.
Give it a way to ship.
Pick something a team wants to build. Agree what it may do. Put it on a platform the company can trust and operate.