Server driven UI for SwiftUI
Server driven UI for SwiftUI means your backend describes a page as JSON and the iOS client renders native SwiftUI, not a WebView.
Read articleBlog
Long-form writing on server driven UI for SwiftUI: architecture, schema, widgets, and production notes. Documentation stays the source of truth; these articles are the why.
Schema6 min read
UI schema atoms: text, color, image, font
Atoms are the reusable JSON shapes behind widgets: TextData, ColorData, ImageData, FontData. Dark variants live on the color atom.
Schema6 min read
SwiftUI JSON schema: pages, sections, widgets
A SwiftUI JSON schema for SDUI is the envelope plus widget layout and atoms. It is a contract, not a visual builder file.
Schema6 min read
The Flow-UI JSON envelope
The Flow-UI JSON envelope is a page with optional header and footer, sections, and widgets. One document describes the whole native screen.
SwiftUI6 min read
Observation, PageStore, and SwiftUI state
PageStore owns the decoded page. WidgetStateStore owns per-widget state. SwiftUI Observation is how the view tree stays in sync.
SwiftUI6 min read
Dynamic SwiftUI screens from a backend
Dynamic SwiftUI screens are pages the backend composes. The client does not hardcode the widget list; it renders whatever the envelope contains.
SwiftUI6 min read
Rendering JSON as SwiftUI on iOS 17
Flow-UI renders JSON as SwiftUI on iOS 17 using Observation and PageStore. Paste a payload in the playground to see the same pipeline.
SwiftUI6 min read
JSON to SwiftUI: how a payload becomes a view
JSON becomes SwiftUI when the registry maps a type string to a WidgetView and the renderer emits that view for each widget in the page.
Schema6 min read
Page, section, widget: the mental model
An SDUI page is sections of widgets. That envelope is the whole contract. Screens and cards are not types in Flow-UI.
Architecture6 min read
How a server driven rendering engine works
The rendering engine walks sections, resolves each widget type in the registry, and lays out native SwiftUI. Unknown types drop out.
Architecture6 min read
Server driven UI architecture
A server driven UI architecture on iOS is decode, registry, contain failures, render widgets, dispatch actions. Flow-UI names those types.
Production3 min read
App Store Guideline 2.5.2 and declarative JSON
A JSON page that picks among widgets already in the binary is data. Downloaded executable code is not. Keep the payload declarative.
Production4 min read
Feature flags vs SDUI vs remote config
Feature flags toggle code you already shipped. Remote config swaps copy and numbers. SDUI rearranges native widgets from JSON. They stack; they are not the same.
Architecture4 min read
When not to use server driven UI
Skip SDUI for maps, heavy gestures, latency-critical canvases, and apps that change UI once a quarter. Use it for feeds, merchandising, onboarding, and experiments.
SwiftUI3 min read
What native means in an SDUI stack
Native SDUI means the widget is a real SwiftUI view: scrolling, gestures, and accessibility come from the platform, not from HTML.
Server-Driven UI4 min read
How to implement SDUI on iOS
Implement SDUI on iOS by decoding a page envelope, registering widgets, containing unknown types, and dispatching actions as data.
Server-Driven UI4 min read
How to build server driven UI in SwiftUI
Build server driven UI in SwiftUI with four pieces: a JSON envelope, a widget registry, a renderer, and host networking. Worked path using Flow-UI.
Server-Driven UI5 min read
SDUI vs WebViews on iOS
SDUI renders native SwiftUI from JSON. A WebView renders HTML in a browser process. Teams pick SDUI when the page should feel like the rest of the app.
Server-Driven UI4 min read
API driven UI and remote UI, explained
API driven UI and remote UI are names for the same idea as server driven UI: the API returns page structure, the iOS app paints SwiftUI.
Server-Driven UI4 min read
Backend driven UI vs server driven UI
Backend driven UI, server driven UI, BDU, and SDUI are the same split: the server describes the page, the client renders native views.
Server-Driven UI5 min read
SDUI for Swift: a practical definition
SDUI for Swift is a JSON envelope, an open widget registry, and a renderer. Not a new language, not a downloaded script.
Server-Driven UI6 min read
SDUI on iOS: native SwiftUI, not WebViews
SDUI on iOS is native SwiftUI rendered from a JSON page. A WebView is a different product with different scrolling, gestures, and accessibility.