Runtime
A language, a GPU renderer, a packager, and the open-source engine beneath them. Write your app once in React; ship it as a real native app on every platform - and keep the web build a real website.
1 React codebase
renders pixel-identically to
The stack, top to bottom
Source flows down: a language compiles to the renderer, the renderer draws to native surfaces, and the packager delivers them - and KilneOS runs the whole stack as a sandboxed desktop.
The idea
One GPU renderer draws the same pixels on every platform and one engine keeps the semantics identical - so there is no WebView fragmentation and no native-component drift. The browser build stays a real website: real DOM, real SEO, real DevTools.
In plain terms
The stack most applications are built on assumes a human is looking at a screen. Layout is computed for eyes, state lives in a document model built for text, and anything a machine wants to do has to be reverse-engineered from markup meant for people. The runtime layer starts from a different assumption: the same application should be equally legible to a person and to an agent.
It is the layer beneath your application - language, renderer and delivery - designed so that a program describing an interface can be rendered for a person and operated by an agent from the same description. Instead of an agent scraping pixels or guessing at a DOM built for humans, it works against a typed representation of what the application can actually do.
Arth exists because the safety properties this layer needs are usually paid for in ergonomics. It takes Java-like syntax and pairs it with Rust-grade memory safety: no garbage collector, no lifetime annotations, no null, compiled to native code. The point is that systems-level guarantees should not require systems-level ceremony from the person writing ordinary application logic.
Arth is the language. Detir is the renderer - a GPU runtime that draws either HTML or a typed intermediate representation, so the same application has a visual form and a machine-operable form. WAID is delivery: write one Vite and React application and ship a real static website plus native desktop, iOS and Android builds, rendered by Detir rather than wrapped in a WebView. KilneOS is the sandbox - a GPU-native desktop you run as an ordinary application, where an agent gets a real computer to drive while deny-by-default brokers scope what it can reach and a replayable audit records every move.
No, and it is explicitly designed not to. WAID's web target is a genuine static website - crawlable, linkable, cacheable - not an application shell that renders nothing without JavaScript. The goal is to stop treating native and web as separate rewrites, not to abandon the open web in favour of a proprietary surface.
Because the alternatives are worse. Giving an agent a shell on a real machine grants far more authority than the task requires, and confining it to a chat window means it cannot use the software people actually use. KilneOS gives it a real desktop with real applications, while the authority it holds is brokered per action and denied by default - so capability and blast radius are decoupled.
Yes. WAID builds and ships applications today without requiring Arth. Detir renders HTML as well as its own intermediate representation. The layers are designed to compose, but each solves a problem that stands on its own - which is deliberate, because a runtime you can only adopt all at once is a runtime nobody adopts.
▷ arthcompile.target→NATIVE
We're onboarding design partners building AI-native apps that need to run natively everywhere without a WebView tax. Tell us what you're shipping.
