OpenUI (C1 by Thesys): LLMs are done just talking; they've started 'painting' interfaces

2026-03-12 | Product Hunt | Official Site | GitHub

30-Second Quick Judgment

What is it?: It stops LLMs from just outputting plain text and lets them directly output interactive UI components (charts, forms, cards, dashboards). It takes 2 lines of code to integrate—just replace your existing OpenAI calls.

Is it worth watching?: Yes. This is critical infrastructure for the evolution of AI apps from "chatboxes" to "dynamic interfaces." With 458 votes on PH, 300+ teams using it, and a $4M seed round, they've open-sourced the core spec. If you're building any AI product, you'll run into this direction sooner or later.

Three Questions About Me

Is this relevant to me?

Target User Profile:

• Teams developing AI Agents / Copilots / Chatbots.
• Product Managers tired of "AI only replying with text."
• Indie developers who want their AI apps to look like more than just a chat tool.

Are you the target user?

• If you're building an AI product where users need to see charts, fill forms, or manipulate data → Yes.
• If you're only building a text-only chatbot (e.g., basic FAQ) → Not yet.
• If you're a frontend dev wanting to add an interaction layer to an AI app → Dive in.

Use Case Scenarios:

• AI Data Assistant → Renders charts directly without you writing Chart components.
• AI Form Generation → User states a need, LLM generates a fillable form instantly.
• Internal Tool Copilot → Queries a database and returns a table instead of a text description.
• Customer Support → Displays an order card directly instead of saying "Your order number is xxx."

Is it useful to me?

ROI Judgment: If you're building an AI product that needs rich interaction, the integration cost is so low (2 lines of code) that it's worth a half-day trial. If text is enough for your product, don't force it.

Is it satisfying to use?

Highlights:

• 2-Line Integration: Just swap the OpenAI endpoint for Thesys; the SDK is compatible.
• Streaming Rendering: UI components display as they are generated, not after the LLM finishes talking. Smooth experience.
• 67% Token Savings vs. JSON: OpenUI Lang is much more token-efficient than JSON, making it faster and cheaper.

What real users are saying:

"After using it to create some of my personal trial apps, I can vouch that Thesys C1 works; it makes the UI way more interactive, dynamic, and scalable, since none of the responses are hard-coded." — Developer on DEV Community

"We've been using C1 by Thesys to enhance our chat UI, and it's been a game-changer. The component generation is top-notch, fast, clean, and incredibly intuitive." — User review on Thesys website

"The fact that it works with GPT, Claude, and Google ADK with just 2 lines of code is really appealing — nobody wants to be locked into one model these days." — Product Hunt User

Common Criticisms:

"The real friction in generative UI isn't rendering components, it's getting the LLM to emit the right structure reliably." — A developer's concern in the PH discussion area.

For Indie Developers

Tech Stack

• Core Language: OpenUI Lang — a compact, streaming-first UI description language (67% more token-efficient than JSON).
• Frontend SDK: React (Crayon SDK), supports custom design systems.
• Backend: OpenAI-compatible API; works with Python / Node.js / FastAPI / Next.js.
• AI Models: LLM-agnostic; supports GPT-5, Claude Sonnet 4, Gemini, etc. GPT-5 and Sonnet 4 are recommended for production.
• Database: Uses MongoDB Atlas on the backend.
• Deployment: Cloud API (SaaS) + Open-source OpenUI for self-hosting.

Core Implementation Logic

Thesys doesn't have the LLM generate React code directly (they tested it, and the results were poor). Instead, they use spec-based rendering:

1. The LLM outputs a structured UI "specification" (not code).
2. The OpenUI Lang parser converts the spec into a component tree.
3. The Crayon React SDK renders the tree into actual UI components.

This approach is superior because the LLM only needs to describe "intent" (e.g., "show a bar chart") without writing complex Chart.js code. Reliability is significantly higher.

Open Source Status

• OpenUI Spec: MIT Licensed, github.com/thesysdev/openui
• GitHub Stats: 269 stars, 35 forks, 9 contributors, primarily TypeScript.
• Package Structure: react-lang (core runtime), react-headless (headless chat state), react-ui (pre-built components), openui-cli (CLI tool).
• C1 API: Closed-source SaaS, free to start.
• Build-it-yourself Difficulty: Medium-High. The spec is open, but the LLM fine-tuning and UI mapping logic in the C1 backend are the core moats. Building a basic version from the open-source parts would take ~2-3 person-months.

Business Model

• Monetization: Usage-based API fees.
• Essentials (Free): $10 free credit, then Pay-as-you-go.
• Pro: Usage-based with priority inference, higher throughput, and dedicated Slack support.
• Enterprise: Private deployment, SOC2/GDPR compliance, dedicated solution engineers.
• Artifacts: 100 pages/month free, then $0.01/page (for generating PPTs/reports).
• Startup Plan: Special startup-friendly pricing available.

Giant Risk

Medium-High. Vercel is already working on AI SDK + v0.dev, Google released the A2UI standard, and CopilotKit has the AG-UI protocol. However, Thesys differentiates by being an "API returns UI" paradigm rather than just a "tool to help you write UI code." While giants might not do the exact same thing short-term, the risk of OpenAI adding native UI output capabilities is real.

For Product Managers

Pain Point Analysis

• Core Pain Point: AI product output is text-only, making the UX feel like chatting with a terminal.
• Severity: High-frequency, essential need. Almost all AI Agent products face the "chatbox is not enough" problem—users want to see charts, fill forms, and click buttons, not read walls of text.
• Existing Solutions: Manually writing frontend components (slow), using Vercel AI SDK (semi-automated), or generating code with v0.dev and integrating it (long workflow).

User Personas

Feature Breakdown

Competitor Comparison

Key Takeaways

1. "2-Line Code" DX: Making the API an OpenAI drop-in replacement drastically lowers the barrier to entry.
2. Spec-based over Code-gen: Reliable because it doesn't ask the LLM to write code, but rather to output a structured spec for rendering.
3. Open Spec + Closed Service: A classic route—build an ecosystem with open source, then monetize with SaaS.

For Tech Bloggers

Founder Stories

• Rabi Shanker Guha (CEO & Co-founder): IIT Kanpur CS grad, former Google engineer, former Head of Engineering at DevRev.ai India (scaled team from 0 to ~150). Previously co-founded Payzie (UPI POS), acquired by Google.
• Parikshit Deshmukh (Co-founder): Design background, formerly led design at Recko, solving complex enterprise UX problems.
• Motivation: They believe the next generation of software interfaces won't be designed by humans but generated in real-time by AI. Traditional UI is static; Generative UI adjusts dynamically to each user's needs.

Controversies / Discussion Angles

• "Is Generative UI a fake need?" — Some argue text is enough for most cases and GenUI is over-engineering.
• "Is LLM-generated UI reliable?" — Can the LLM guarantee a correct UI structure every time? How are edge cases handled?
• "Open Spec vs. Closed API" — Is this "true open source" or just "open-source marketing"?
• "Will OpenAI kill this?" — If GPT natively supports UI output, does Thesys's middle layer still have value?

Hype Data

• PH Votes: 458 (Solid traction).
• GitHub: 269 stars (Growing fast since release).
• User Base: 10,000+ devs have used C1; 300+ teams in production.
• Funding: $4M Seed (Led by Together Fund, 8VC participating).
• Twitter: @thesysdev is active with technical deep dives and demos.

Content Suggestions

• The Paradigm Shift: "The Next Frontend Paradigm for AI Apps"—moving from text to Generative UI.
• The MCP Angle: Combine with the MCP protocol hype: "MCP + Generative UI = The Complete Interaction Layer for AI Agents."
• The Comparison: "v0.dev (Code Gen) vs. C1 (Runtime UI Gen)"—explaining the fundamental differences.

For Early Adopters

Pricing Analysis

Note: LLM token costs are extra and billed by your provider (GPT-5/Claude, etc.).

Getting Started Guide

• Time to Hello World: 30 minutes to run a demo.
• Learning Curve: Low (if you've used OpenAI's API).
• Steps:
  1. npm install @openuidev/react-lang @openuidev/react-ui
  2. Change the OpenAI client base URL to the Thesys endpoint.
  3. Render the LLM-returned UI using the C1 React SDK.
  4. Try it out in the Playground.

Pitfalls & Complaints

1. Web Only: No React Native / Flutter support yet; mobile is a no-go for now (planned).
2. LLM Instability: UI structures might break in edge cases; requires fallback handling.
3. Model Dependency: Production requires GPT-5 or Sonnet 4; other models vary in quality.
4. Design Consistency: OpenUI doesn't enforce a design paradigm yet, so styles might vary between models.

Security & Privacy

• Data Storage: API calls go through Thesys cloud.
• Compliance: Enterprise tier supports SOC2, GDPR, and ISO 27001.
• Private Deployment: Enterprise users can deploy privately so data never leaves their network.

Alternatives

For Investors

Market Analysis

• Generative AI Market: Expected $140B-$161B by 2026, CAGR 28%-40%.
• AI Infrastructure Market: Expected $227B by 2030, CAGR 25.7%.
• AI Agent Market: Expected $47B by 2030.
• Sub-sector (AI Frontend Infra): Not yet tracked separately, but "Code Generation" has a CAGR of 49.4%.
• Drivers: The evolution from "chatbox" to "full interface" is inevitable; 88% of enterprises have already adopted AI.

Competitive Landscape

Timing Analysis

• Why Now?:
  1. LLMs are finally strong enough to generate structured UI specs.
  2. AI Agent explosion has made text-only interaction a bottleneck.
  3. The MCP protocol is driving the AI tool ecosystem; the UI layer is the next missing piece.
  4. Code generation latency has dropped to milliseconds, making real-time rendering viable.
• Tech Maturity: Early maturity; spec-based approach is proven.
• Market Readiness: 300+ teams already validating in production.

Team Background

• CEO Rabi Shanker Guha: IIT Kanpur → Google → Payzie (Acquired) → DevRev (0→150 people) → Thesys.
• Co-founder Parikshit Deshmukh: Design background, Recko Design Lead.
• Team DNA: Engineers from Google, Nutanix, and DevRev.
• Headquarters: San Francisco.

Funding Status

• Raised: $4M Seed (June 2024).
• Lead: Together Fund (Manav Garg).
• Participating: 8VC (Bhaskar Ghosh).
• Valuation: Undisclosed.

Conclusion

In short: Thesys's C1/OpenUI is defining the "frontend layer for AI apps"—turning LLMs from "talkers" into "interface painters." The direction is right, the timing is perfect, and the DX is excellent, but the space is crowded with giants.

Resource Links

2026-03-12 | Trend-Tracker v7.3 | Sources: Product Hunt, GitHub, Thesys Official, InfoWorld, BusinessWire, X/Twitter