The UI language humans, AIs, and programs can write

Fuaran is a closed, typed language for describing interfaces. Humans, AIs, and programs can all author the same validated trees — no generated code to sandbox, no free-form markup to sanitise. Every tree is checked against a fixed vocabulary of components before anything renders.

Because a Fuaran interface is a value, not a program, it can be stored, diffed, versioned, streamed, and rendered on the web, on the server, or natively on mobile. One definition, nine language surfaces, and a single wire format.

Here is the whole idea in one example. The card below is the JSON that follows it, decoded, validated and server-rendered by Fuaran itself (every page on this site is a Fuaran tree):

An assistant that answers with a live dashboard instead of a wall of markdown; a server that drives its client's screens as data; one interface definition rendered on web, desktop and mobile: that is what a UI language is for.

Why a language, not generated code

Generative UI has a trust problem: a model that writes React ships arbitrary code, and a model that writes HTML ships whatever it likes. Fuaran closes the problem by shape:

• Safe by construction. The vocabulary is closed: typed node kinds for layout, text, metrics, forms, charts and tables, with no script and no free markup. Every tree is decoded and validated before it renders; what the language does not allow cannot be expressed at all. Malformed input is a typed refusal with a code and a path, not a plausible-looking render – see default-deny by shape.
• A UI is a value. Because the interface is data, it can be stored, diffed, versioned, replayed and generated. An AI emits the same trees a hand-written program does, and both pass the same gates; the examples on this site are themselves build-failing if they stop validating.
• One wire, nine languages. Author in F#, C#, VB, TypeScript, Python, Go or Rust; render in the browser, server-side, or natively via Swift and Kotlin. Every host reads and writes the same core@1.0 wire format, held byte-identical by a shared conformance corpus.

The safety claim is checkable rather than asserted. The wire format carries the renderer's URL-scheme floor (§19) and the decoder's resource limits (§21) as normative obligations, and §21.5 records which hosts enforce them today rather than leaving a reader to assume all of them do.

These are measured claims, not asserted ones – the evaluation publishes how reliably models produce correct, conformant interfaces, with full provenance on every figure.

See it live: open the playground → and describe an interface in plain English with your own API key – the tree builds and renders as the model emits it.

Prefer to look first? Browse the gallery → – live demos of what UI-as-data can do, no key needed.

Get started

Pick your language – install, author (or decode) a tree, and open it in the playground. Nine surfaces, grouped by ecosystem:

• .NET – one canonical encoder, three author surfaces: F# (the reference host, Fuaran.UI) · C# (the Fuaran.UI.CSharp fluent factory) · VB (XML literals or the C# fluent factory, checked at compile time).
• Web – TypeScript (@fuaran-ui/ui + @fuaran-ui/ops).
• Python – Python (fuaran-py).
• Systems – Go (the headless backend / orchestrator host) · Rust (dual-role: headless / edge and browser-native WebAssembly).
• Native UI – Swift and Kotlin, native render-projection surfaces over the Rust reference core (SwiftUI / Jetpack Compose).

Then explore

• The guide – the wire format, rendering, and the language surfaces.
• Hosts – the nine language surfaces and what each one promises.
• Component reference – every node kind, rendered beside its wire JSON.
• Security – what the format guarantees, which host enforces what today, and what the application still owns.
• Try it live – describe a UI in the playground and watch the tree build.