StemJSON offers a JSON dialect that lets LLMs build native mobile UI on the fly

A JSON dialect for AI-built native interfaces

StemJSON, a project that reached the Hacker News front page via a Show HN post, is a declarative language built on JSON with a specific ambition: giving AI models a format in which they can describe complete native mobile app UI and logic, which a device-side runtime then renders as real platform UI.

According to the project's site, the language was created by Vasyl Krychun and is meant for building new apps or extending existing ones, whether the StemJSON comes from an AI tool, a backend or a design environment. The format is open, and the specification covers components, actions, expressions, state, navigation and the conformance rules that runtimes enforce, so a developer can know in advance exactly what a module can and cannot express.

How the runtime handles LLM output

The headline use case is what the site describes as a sandboxed region inside an existing app. An end user types a request in plain language; an LLM turns that prompt into a StemJSON document; the runtime validates the document, renders it as a fully native module, and confines it to the sandbox boundaries the developer defined. According to the project, no new binary is needed and there is no backend round-trip for the UI itself, since rendering happens on the device. The site also notes that this approach is patent pending.

The validation step deserves attention. Model output is treated as untrusted input that must satisfy the language's conformance rules before anything renders, which is a different trust model from letting an LLM write and run arbitrary application code.

Beyond the AI sandbox

The project lists three further uses:

Server-driven UI. A backend can push complete functional modules, including state, actions, expressions, navigation and validation, straight to devices, following the established pattern of changing app behaviour without an app-store release.

Prototyping and design tools. A prompt or a Figma export can become a runnable native prototype: the tool emits StemJSON and the runtime renders it on-device, with no glue code in between.

Hybrid codebases. Teams can keep most of an app hand-written and drop StemJSON modules into the parts that change often, such as settings screens, onboarding flows and content feeds.

Availability

The full specification is published on the project's site, and Swift and Kotlin SDKs provide native rendering on iOS and Android. The runtime is offered with a free tier that has no time limit, and the project publishes open-source example apps with the runtime already integrated, which can be cloned and extended with a custom .stem file. Feedback on the specification runs through GitHub issues.

Why it matters

Native mobile development has sat awkwardly within the current wave of AI code generation: a model can draft Swift or Kotlin, but the output still has to be compiled, reviewed and shipped through store review before anyone sees it. StemJSON reframes the problem. Instead of generating code that runs, the model generates a declarative document that a runtime checks and renders inside limits the developer set. That extends the server-driven UI pattern to user-initiated, prompt-driven features, and the open format invites AI toolmakers, IDE plugins and prototyping tools to emit it. Open questions remain, including how expressive the language proves in practice, whether rendered modules truly match hand-written UI in performance, and what the pending patent means for a format its creator wants widely adopted. Still, the core pattern, a validated declarative document serving as the contract between an LLM and a device, is one we are likely to see again.