LUI is a server-driven architecture that collapses the entire presentation layer into plain-text tokens streamed from a secure backend. No client-side schemas. No duplicated state. No SPA complexity. Just a spatial layout engine that renders what the server says you can see.
Every LUI screen carries a contextual AI sidecar panel. Type a natural-language prompt and the backend compiles a valid layout patch, rebalances spatial coordinates, and streams the updated token block to the client edge — all within a single SSE frame.
The AI bridge formats the full spatial context — the active Page → Row → Component coordinate block, user history, and permission scope — into a structured prompt. The model responds strictly with a valid LUI layout patch. No freeform text. No hallucinated components. Just geometry.
The sidecar captures the prompt and appends the current page layout context.
The AI responds with a structured token block. The cascade compiler validates it against the user's permission scope and any Untouchable constraints.
Existing components smoothly animate to their new widths. The new MetricCard fades into position.
The change persists in the ephemeral session layer. Promote it to userDefault_view to save permanently, or discard it when the session ends.
Provider-agnostic by design. The AI bridge is a wrapper interface. Swap between Anthropic, OpenAI, or local Ollama pipelines without changing a single layout token. The framework owns the context formatting and output validation — the model just fills in the geometry.
Traditional enterprise architectures duplicate every piece of presentation logic: once in the database, and again in a heavy JavaScript SPA. Routing, validation, permissions, field visibility — all maintained in two places, drifting apart over time.
LUI eliminates the duplication by making the server the absolute owner of both screen geometry and application capability. The client edge runtime is a stateless spatial interpreter. It accepts plain-text tokens, maps them to hardware-accelerated view primitives, and renders. No compilation pipeline. No local routing. No persistent business logic.
The client owns rendering, not decisions. Think of it as a GPU for your application layout. It draws what it's told — fast, smooth, and without opinions about what should be on screen.
Every UI element lives at an explicit geometric coordinate. No arbitrary nesting. No wrapper divs. No CSS grid guesswork. Three tiers, deterministic layout.
| Invoice ID | Account Name | Status |
|---|---|---|
| INV-2026-001 | Vanguard Supply Corp | Pending |
| INV-2026-002 | Stark Manufacturing | Approved |
When multiple components share a row, width is divided equally by default. Two components get 50/50.
Three get 33.3/33.3/33.3. Asymmetric splits require an explicit width declaration —
nothing is ever ambiguous.
The Go backend streams LUI tokens over SSE. It never sends HTML, JSON, or platform-specific markup. Each target platform ships its own LUI interpreter — a thin, deterministic parser that maps tokens to native view primitives. The token format is the cross-platform contract.
When a route is requested, the backend compiles five configuration layers from bottom to top. Each layer can override the one below it — unless an element is marked Untouchable.
| Layer | Name | Scope | Lifetime |
|---|---|---|---|
| 1systemDefault | Global platform blueprint | All tenants | Infinite |
| 2tenantDefault | Organization overrides | Single tenant | Infinite |
| 3roleDefault | Permission-scoped structure | Access group | Infinite |
| 4userDefault | Personal workspace settings | Single account | Persistent |
| 5session | Live sandbox & AI previews | Active session | Ephemeral |
This isn't a config file hierarchy. These are database rows. The cascade is compiled inside a Postgres query at request time, meaning layout compilation participates in the same transactional guarantees as your business data. No eventual consistency. No stale cache. No race conditions.
The same invoice console page, compiled through four cascade layers. Click each tab to see what changes, what gets locked, and what disappears entirely.
| Invoice ID | Account | Status |
|---|---|---|
| INV-2026-001 | Vanguard Supply Corp | Pending |
| INV-2026-002 | Stark Manufacturing | Approved |
| Invoice ID | Account | Region | Status |
|---|---|---|---|
| INV-2026-001 | Vanguard Supply Corp | APAC | Pending |
| INV-2026-002 | Stark Manufacturing | EMEA | Approved |
| Invoice ID | Account | Region | Priority | Status |
|---|---|---|---|---|
| INV-2026-001 | Vanguard Supply Corp | APAC | HIGH | Pending |
| INV-2026-002 | Stark Manufacturing | EMEA | LOW | Approved |
| INV-2026-003 | Oscorp Industries | AMER | CRITICAL | Flagged |
| Invoice ID | Account | Region | Priority | Status |
|---|---|---|---|---|
| INV-2026-001 | Vanguard Supply Corp | APAC | HIGH | Pending |
| INV-2026-002 | Stark Manufacturing | EMEA | LOW | Approved |
| INV-2026-003 | Oscorp Industries | AMER | CRITICAL | Flagged |
Four layers. One query. Zero ambiguity. Every pixel Maria sees is the deterministic result of compiling systemDefault + tenantDefault + roleDefault + userDefault in a single Postgres query. Change a rule at any layer and the downstream output updates instantly. No cache busting. No client-side diffing. No "have you tried clearing your browser?"
In multi-tenant enterprise software, certain UI elements are non-negotiable. A compliance banner that legal requires. An audit trail that regulators mandate. A billing widget the SaaS provider needs. LUI makes these constraints structurally unbreakable.
Any component, row, or section in the cascade can be flagged 🔒 untouchable by the layer that owns it. Once locked, no downstream layer can override, hide, move, or modify that element. The lock is enforced during cascade compilation — not at the client, not in middleware, but inside the database query itself.
The cascade respects the hierarchy. Layer 1 untouchables cannot be unlocked by Layers 2–5. Layer 2 untouchables cannot be unlocked by Layers 3–5. An Untouchable is a downward-only lock — the layer that created it is the only layer that can remove it. This makes compliance auditable by construction: you can query the database for every Untouchable constraint and prove exactly what every user sees.
When the AI sidecar generates a layout patch, the cascade compiler validates it against all active Untouchable constraints before streaming the update. If the patch attempts to modify a locked element, it's rejected with a structured error — the user sees a clear message explaining which governance rule blocked the change and which authority owns the lock.
Because layout rendering happens inside a secure database context, unauthorized accounts never receive the tokens for actions they can't perform. The component block is dropped during cascade compilation. It never reaches the client DOM.
| Invoice ID | Account | Status |
|---|---|---|
| INV-2026-001 | Vanguard Supply | Pending |
| Invoice ID | Account | Status |
|---|---|---|
| INV-2026-001 | Vanguard Supply | Pending |
Render the button, hide it with CSS or a client-side permission check. The DOM node, the API endpoint, and the action label are all present in the page source.
The server never emits the component token. No DOM node. No endpoint reference. No label string. The attack surface was never transmitted.
LUI replaces nested JSON and YAML with a space-conscious, comma-delimited notation. Schema headers are defined once; raw values stream line-by-line. The result is smaller payloads, faster parsing, and configuration files that humans can actually read.
JSON is designed for machine interchange, not human authorship. LUI tokens are designed to be read by developers, written by AI, and parsed by edge runtimes with minimal overhead. The tabular array syntax (define headers once, stream values) maps directly to the relational data model underneath — what you see in the token stream is what's stored in the database row.
Interactive capabilities — disabling elements, hiding rows, validating inputs — are declared in an isolated logic block at the tail of the configuration payload. Structured in Disjunctive Normal Form: an OR of ANDs.
The + operator is a strict AND: both conditions must be true.
The , separator creates independent OR channels: any single branch passing
is sufficient. This structure lets edge engines evaluate interactive constraints with lightweight
regex operations at 120fps — no JavaScript framework required.
Because logic blocks are separate from component declarations, the same constraint can be applied, removed, or overridden at any layer in the cascade without touching the layout geometry.
LUI's durable execution layer runs on Temporal with Postgres persistence — the same engine trusted by Uber, Netflix, and Stripe for mission-critical workflows. Every user interaction is an idempotent, resumable transaction.
| Invoice ID | Status |
|---|---|
| INV-2026-001 | Posted |
| Invoice ID | Status |
|---|---|
| INV-2026-001 | Pending |
The edge runtime updates the UI instantly — changing numbers, badge styles, component states — before the network request completes.
Interactions are queued client-side and pushed as a single payload signed with an auto-generated LUI-Sync-Token.
Duplicate submissions (network flaps, retries) are detected via token hash and replayed — never executed twice.
On failure, the server sends an error layout patch. Components animate back to historical state with a global error toast.
Multi-step operations run as durable workflows. Server power loss mid-transaction? Execution resumes at the exact step it dropped.
Backend-agnostic by design. DBOS is the reference implementation, not a hard dependency. The durable execution contract can be fulfilled by Temporal, Inngest, or any system that provides deterministic replay and transactional step isolation.
LUI isn't another frontend framework. It's an architectural position: the server should own both what you see and what you can do. The client should be fast, beautiful, and utterly opinionless about business logic.