SDL — interfaces as validated data
SDL — interfaces as validated data
SDL is Furnace's server-driven UI language: a closed, validated JSON format for describing a screen as data instead of code. An SDL document is not a template that generates markup — it is the interface itself, interpreted at render time by a renderer that only understands one closed vocabulary: the components of the design system.
A flat, ID-keyed graph
A document is a flat map of nodes, each addressed by a stable string ID. Children are referenced by ID rather than nested inline. That shape is deliberate: a partially generated or partially edited document loses at most one node, not an entire subtree, and an editor — human or AI — can patch a single entry without reconstructing the whole page around it.
A closed vocabulary, not an open canvas
Every node's type comes from a fixed registry of design-system
components — there is no way to author a node type that doesn't correspond
to a real, accessible, tokenized component. There is no arbitrary styling:
no raw colors, no pixel values, no custom CSS. A rendered SDL page is meant
to be indistinguishable from a hand-built page, because it is built from
exactly the same parts.
This closedness is also the security boundary. A document can describe what to show and which declared data to bind, but it cannot execute code, reach outside its granted data, or crash the renderer — those guarantees come from the interpreter and the server, never from trusting the document's author.
Data binding through one governed door
An SDL document doesn't carry live data — it declares bindings to named data sources, resolved through a single governed capability chokepoint at render time. The document is inert; every read is checked and served fresh on each render, so persisting a document never persists someone else's data alongside it.
Interactivity as declarative envelopes
Actions — submit a form, navigate, open a dialog, mutate a record — are expressed as small declarative envelopes (an action name plus arguments), not as embedded code. The renderer interprets the envelope and dispatches it through the same governed paths a hand-written component would use.
Why closed-and-validated matters for AI-generated UI
An LLM asked to produce a screen is far more likely to succeed, and to successfully repair its own mistakes, against a small closed grammar than against arbitrary code. SDL documents are validated in two passes — shape, then structure — and every validation failure is written as a message meant to be pasted directly back into a model's next turn as a repair instruction. Because the vocabulary is closed, the tool can also derive a JSON Schema from it and hand that schema straight to a model, so an agent generates directly against the same contract the server enforces — no separate prompt-engineered dialect to keep in sync.