Discussion points

Short, one-page positions on the design decisions that make Fuaran UI different – and honest about where the ideas came from, what the alternatives do well, and where the limits are. Each page is dated; comparisons cite the compared project's own documentation, and we update when the landscape moves.

They read in order – each group builds on the one before – but every page stands alone.

I. What the interface is

The founding decision: the interface is a durable, canonical artefact, not a rendering instruction.

• Records, not just renders – how Fuaran differs from rendering-instruction protocols such as Google's A2UI, and why the difference is in what the data is once it exists.
• Canonical bytes – one encoding, byte-identical from every host, and why hashing, diffing, and merging are unbuildable without it.
• The interface as a value – history, provenance, replay, forks, and real merges, because the app is data.
• The vocabulary is data too – the language's own definition as a typed IDL, with the structural layer and canonical encoder generated from it – and the byte-diff that proved the swap moved nothing.

II. Authoring with AI

What changes when the language expects two author classes – human and model – from the first design decision.

• Two authors, one language – the twin-surface design, and the four failure modes of treating a model as a text generator over a human-authored language.
• Default-deny by shape – typed refusals as the quality gate for AI-emitted UI, and the safety gate for everything else.
• Errors that enumerate the fix – a rejected edit returns the alternatives that would have succeeded, so most recoveries need no model call.
• Identity that survives the conversation – permanent node ids, so turn twelve edits the same components turn two meant, and local state survives.
• The unhappy path is in the type – loading, empty, and error are required slots, not conventions an AI author can skip.
• Edit the running app, not its code – the AI edits the live tree through typed operations; source files stay human territory.

III. Operating and asking

A deployed interface as a surface a human and an agent share – safely, cheaply, and in both directions.

• Declared, not scraped – nodes declare what an agent may operate, with typed decoders, projected value spaces, and grep-able authorisation.
• The fastest model call is none – declared patterns and structural search resolve the mechanical majority in microseconds; the model is for the residue.
• Typed questions, typed answers – when the agent needs a human decision, it asks with a live form and a declared contract, never prose.

IV. Rendering and reach

Where the artefact goes: every pipeline, every device, verified on arrival.

• One tree, every pipeline – client, server, and hydration renders locked by an executable parity corpus; crawlable, no-JavaScript first paint by design.
• Verified without screenshots – design conformance as quantified invariants over resolved computed styles; deterministic, CI-gateable, no vision model.
• Teleport without a server – moving a live UI between devices as ~2KB of typed data over a direct peer connection, with the connectivity limits disclosed.