Skip to content

Vision

Where VLLNT UI is going: generative UI with json-render and the AI SDK, voice-first, 3D, AR and holographic interfaces, glass by default, and what ships today.

VLLNT UI is the UI layer that every vllnt product is built on: the web today, React Native at canary, desktop and spatial next. The aim is to be the fastest way for people and AI agents to build interfaces. The vllnt brand is the default theme, and every component meets WCAG 2.2 AA.

Interfaces are changing in five ways: generative, voice-first, 3D, AR and spatial, and holographic. VLLNT UI is built to be the foundation for all five.

Platforms

VLLNT UI is meant for every kind of interface. This is where each target stands today.

  • Web (React DOM, Next.js): shipped. @vllnt/ui is on npm, with stable releases and a canary on every change.
  • Mobile, React Native (iOS, Android, Expo): canary. @vllnt/ui-native publishes canary builds only; there is no stable release yet. Each canary is installed in a clean Expo app and exported for iOS and Android before it counts. See Native.
  • Desktop, Electron and Tauri: roadmap. Nothing desktop-specific exists yet: no desktop tests, packaging or guidance.
  • Desktop, native macOS apps: roadmap. There is no SwiftUI or AppKit renderer.
  • 3D, in-page scenes: roadmap. Only pseudo-3D pieces ship today: Globe3D (an SVG projection) and TiltCard (CSS 3D). There is no WebGL scene layer yet.
  • AR and spatial, visionOS and WebXR: proposal. The spatial foundations are an open RFC (vllnt/ui#631). There is no spatial renderer.
  • Holographic interactive interfaces: roadmap. Some building blocks ship on the web: glass-style surfaces (GlassPanel, GlassCard, LiquidGlass), a ring gauge (ThresholdRing), HUD controls (ZoomHUD) and docks. They use local blur values; glass tokens come with vllnt/ui#684. The holographic components themselves do not exist yet.
  • AI-generated, streamed UI: partly shipped. Descriptors, the MCP server, themes as data and streaming components exist; the json-render and AI SDK adapters do not (vllnt/ui#672).
  • Voice-first UI: roadmap. No voice component ships yet: no transcript, listening state, waveform or speech output. Streamed text is already announced through a live region by AIStreamingText.

One core, one renderer per platform

The rule that makes this possible: the core stays platform-neutral, and each platform is a renderer on top of it.

  • The core holds what every platform shares: design tokens, component contracts (the names of options and props), platform rules and, later, the props schemas behind each descriptor. It has no runtime dependencies and does not import any renderer.
  • A renderer turns the core into real components for one platform: @vllnt/ui for the web and @vllnt/ui-native for React Native today, and desktop, macOS, visionOS or WebXR renderers later.
  • Dependencies point one way. Renderers depend on the core, never the reverse, and one renderer never imports another. A decision two platforms share goes into the core first.

Today, the native package reads its tokens and contracts from @vllnt/ui-core, and the web package gets the same tokens as generated CSS. Moving the props schemas into the core is on the roadmap.

1. 3D, spatial and holographic interfaces

AR and spatial devices place UI in the room around you, not on a flat screen, and 3D scenes put it in depth on any screen. The pieces stay the same: buttons, lists, dialogs, text. What changes is depth, how you point (hand, gaze, voice) and how big a target needs to be.

Holographic interactive interfaces push this further: layered translucent panels in depth, data-dense HUD overlays, radial and orbital menus, input by gesture, gaze and voice, and panels that are streamed live or generated by an agent. We want them built from the same tokens and components, with the same accessibility rules.

The goal is that the same components and tokens render on a phone, on a laptop and in space, without a separate kit for each.

2. Dynamic, AI-composed UI

More and more, an interface won't be designed once and shipped to everyone the same. A model or a server will compose it at runtime from known parts, stream it to the screen as it is generated, fit it to the person using it, and update it without waiting for a new app release.

For that to work, the parts have to be:

  • Describable: an agent can find a component, read what it does and which props it takes, and use it correctly.
  • Data-driven: a component is fully set by its props, and a theme is data, so both can be sent over the wire.
  • Stream-safe: a screen holds its layout while content is still arriving.
  • Safe to update: a new version doesn't break the screens already built on the old one.
  • Accessible by default: a generated screen meets WCAG 2.2 AA just like a hand-built one.

3. Voice-first interfaces

Next-generation interfaces will be generated, and many will be voice-first. The UI follows the voice: a person speaks, the interface shows that it is listening and what it heard, answers out loud and on screen, and can stream generated UI in reply.

For that, VLLNT UI needs:

  • Conversational surfaces that combine a transcript, the reply and any generated UI in one place.
  • A live transcript and listening states: interim and final text, and clear idle, wake, listening, thinking, speaking, muted and error states.
  • Push-to-talk and wake states that also work by keyboard and switch.
  • Waveform and level indicators that never carry meaning by motion alone, and stay still when motion is reduced.
  • Spoken feedback with a text equivalent: every spoken answer is also visible, selectable text.
  • Voice-driven streamed UI: a voice turn feeds the AI SDK or a json-render spec, and the screen updates as the reply streams.

None of this ships yet. It is tracked in vllnt/ui#683.

Glass by default

Glass is to become the default look of VLLNT UI everywhere, page chrome and this site included. Underneath, the base stays the same: black and white, Inter and JetBrains Mono.

  • Readable first. Panels that carry text use enough blur and tint, or opacity, to meet WCAG 2.2 AA contrast.
  • Solid when needed. A solid surface replaces glass automatically when the user asks for reduced transparency or more contrast, on low-power devices, and on native platforms without blur. Every glass component also ships a solid variant.
  • Within a budget. Blur costs rendering time, so the number of blurred layers and their radius have a performance budget.

This is decided but not built yet: today the default theme is solid. The switch is tracked in vllnt/ui#684.

Working with the Vercel AI stack

We want VLLNT UI to be first-class with two open tools from Vercel:

  • json-render: you define a catalog of components, each with a zod props schema and a description. The model emits a JSON spec (streamed as JSON patches), and a renderer turns it into React. A VLLNT UI catalog would let models build screens out of VLLNT UI components.
  • AI SDK generative UI: a tool call arrives in useChat as a message part of type tool-<name>, with a state (input-streaming, input-available, output-available, output-error) that maps to loading, result and error views. The AI SDK also offers streamUI for React Server Components, which its docs mark as experimental.

Today no adapter ships. VLLNT UI components are plain React components, so you can already render AI SDK message parts with the AI family (AIStreamingText, Reasoning, AIToolCallDisplay, AISourceCitation, ApprovalRequest and more) in your own code. Next is a json-render catalog, zod prop schemas for every component, and helpers that map AI SDK tool parts to components with their loading and error states: vllnt/ui#672.

Principles

VLLNT UI is built on a set of core principles that guide every design decision and implementation choice. All components follow these principles. When you use VLLNT UI, you're not just adding components. You're adopting a philosophy of clean, fast, and purposeful design.

Minimalist design

Less is more. Every component is designed with simplicity at its core. We believe that good design should be invisible. It should work seamlessly without drawing unnecessary attention to itself. Our components are:

  • Clean and uncluttered
  • Focused on essential functionality
  • Free from decorative elements
  • Purposeful in every detail

Dark mode first

Dark mode isn't an afterthought. It's the primary design direction. Every component is crafted with dark backgrounds in mind, ensuring optimal readability and visual comfort. Light mode is available, but dark mode is where VLLNT UI truly shines.

  • Designed for low-light environments
  • Reduced eye strain
  • Modern aesthetic
  • Professional appearance

No emoji style

We maintain a professional, text-based approach. Emojis and decorative icons are kept to a minimum, ensuring our components remain timeless and universally applicable.

  • Text-first communication
  • Professional tone
  • Universal compatibility
  • Clean typography

Technical excellence

Beyond aesthetics, VLLNT UI prioritizes:

  • Type safety: built with TypeScript for reliability
  • Customization: easy to extend and modify
  • Modern standards: built on the latest web technologies

What ships today

  • Describable components. Every component has a JSON descriptor at /r/<name>.json, indexed in /r/registry.json. Agents can also use /llms.txt, /llms-full.txt and the MCP server at /mcp (search_components, get_component, list_categories). Every descriptor carries its version and stability; prop definitions and usage examples exist for only a few components so far. See Agents.
  • Tokens and themes as data. One token source generates the CSS variables, the product themes (switched at runtime with data-theme), the React Native tokens and the Penpot libraries. See Theming.
  • Streaming-ready parts. Skeleton for loading states; AIStreamingText, Reasoning, ThinkingBlock and AgentActivity for output that arrives piece by piece. See the AI components. Components work with React Server Components, and client components are marked "use client".
  • Safe updates. Semantic versioning, a canary build on every change to main, stable releases only from reviewed tags, the latest tag never moves backwards, and every release lists its upgrade notes. See Changelog.
  • Accessibility gate. Every story is tested with axe against WCAG 2.0 to 2.2, levels A and AA, in light and dark themes. Any violation fails the build.
  • Shared core for more than one renderer. @vllnt/ui (web) and @vllnt/ui-native (React Native) are generated from the same tokens and component contracts; the native package reads them from @vllnt/ui-core. Every interactive native component shares one affordance primitive for its pressed, hovered, focused and disabled states. See Native.

On the roadmap

None of these ship yet. They are the next steps toward the vision.

  • Spatial foundations (proposed for 0.5.0): depth tokens, one affordance contract for pointer, touch and gaze, target sizes that adapt to the input (24 px pointer, 44 pt touch, 60 pt spatial), and motion tokens. The proposal is an open RFC: vllnt/ui#631.
  • Spatial renderers such as visionOS or WebXR, built on the same core.

3D, AR and holographic interfaces

Each of these is open work, tracked in its own issue. Nothing here ships yet.

  • A 3D scene layer: optional React Three Fiber and WebXR adapters, as optional peer dependencies and never inside the core (vllnt/ui#678).
  • Depth and elevation tokens, shared by 3D, spatial and layered glass, from the spatial RFC (vllnt/ui#631).
  • Spatial input: gesture and voice on top of the pointer, touch and gaze contract, with every action still reachable by keyboard (vllnt/ui#680).
  • Holographic components: radial and orbital menus, a data ring, a holo panel and a documented glass layering pattern, built on the existing glass and HUD components (vllnt/ui#679).
  • Accessibility for spatial and translucent UI: reduced motion, reduced transparency, contrast on glass and spatial target sizes, on top of WCAG 2.2 AA (vllnt/ui#681).
  • Schemas so agents can stream them: json-render catalog entries and AI SDK tool schemas for these components (vllnt/ui#672).

Voice-first interfaces

  • Voice-first components: a conversational surface, a live transcript, a listening indicator, push-to-talk, waveform and level meters, and spoken feedback with a text equivalent (vllnt/ui#683).
  • Voice-driven streamed UI through the AI SDK's speech and transcription functions (some are still marked experimental) and through json-render (vllnt/ui#672).

Glass by default

  • Glass tokens and the default switch: blur, tint and opacity tokens, glass as the default theme, automatic solid fallbacks, contrast tests on glass and a backdrop-filter performance budget (vllnt/ui#684).
  • A complete props schema for every component, so a model can produce a valid UI tree and a renderer can check it before showing it.
  • A partial-props contract, so any component can render from incomplete, streamed data.
  • Per-user themes resolved at runtime, kept inside the accessible token ranges.
  • Codemods and a written deprecation window, so updates can be applied automatically.
  • Accessibility checks on generated UI trees, run before a generated screen is shown.
  • json-render catalog and AI SDK helpers for VLLNT UI (vllnt/ui#672).

How to follow along