Interfaces, described in JSON

An open specification for declaring dynamic user interfaces: structure, data binding, validation, and behavior in one portable JSON document.

Read the docs Browse the keywords

{
  "$schema": "https://example.com/ui-schema/app",
  "type": "form",
  "props": {
    "onSubmit": { "$action": "submit" },
    "children": [
      {
        "type": "input",
        "props": {
          "label": { "$t": "signup.email" },
          "value": { "$field": "/email" }
        }
      },
      {
        "$if": { "$data": "/acceptedTerms" },
        "$then": {
          "type": "button",
          "props": {
            "label": { "$t": "signup.submit" }
          }
        }
      }
    ]
  }
}

From document to interface

The specification separates what a UI is from how it gets rendered:

Language: The keywords, composition rules, and semantics defined by the specification.
Dialect: Element definitions composed into a JSON Schema meta-schema, defining the element types and props documents may use.
UI Schema: A document written in the language and a specific dialect, describing the UI to render.
Engine: Interprets a document and its data context, mapping each element type to a renderer component and managing state, events, and validation.

What it unlocks

When an interface is data, it can come from anywhere — a model, a database, an editor:

Generative UI with guardrails

Let an LLM compose interfaces without writing free-form code. The dialect constrains generation to known elements, props, and actions — every document validates before it renders.

Server-driven UI

Ship new screens and flows from the backend without a client release. Clients render whatever document the server sends.

Form builders

Store forms as data: field bindings, validation, and conditional logic live in one document, editable without touching the frontend.

CMS and page builders

Let editors compose pages from an element catalog. The output is portable JSON, decoupled from any particular frontend.

Cross-platform rendering

One document, many engines. Map the same element types to web, mobile, or native renderers.

Experiments and personalization

Swap documents per user, segment, or experiment at runtime — no deploy required.