GolemUI turns v1

Jun 15, 2026

Nice to meet you

You probably haven’t heard of us, but there’s a decent chance you’ve used something we built. We’re a team of three, and we’ve spent decades writing software for the web, most of it on enterprise projects where the forms are never simple, never finished, and never quite the same twice.

This is not our first form engine. It’s not our second, either. We’ve been building them for longer than we care to admit, and GolemUI is what we arrived at after learning the same lessons enough times to stop repeating them.

The problem with forms

Forms are everywhere, and yet we keep rebuilding them. A form built for React can’t be reused in Angular. A form locked inside component code can’t be stored, versioned, or A/B tested, or handed to a non-engineer to edit. And a form that only exists as JSX is awkward for a machine to generate, because there’s no clean shape to target.

And the cost isn’t only ours. Forms are where users quietly give up: every extra field measurably hurts completion, and the longest forms bleed the most.

We wanted forms that were none of those things. Portable. Editable. Generatable. The same form, everywhere, owned by data rather than by a framework.

The idea: forms as data, `{gui.}` on top

Here is the whole idea in one line: a form is data, with a typed authoring layer on top.

Underneath, every GolemUI form is a serializable JSON schema . Portable, storable, framework-independent. On top sits {gui.}, our DX layer: a typed, autocompletable builder that constructs that schema for you. You write {gui.}, you get JSON. The portability of data, with the ergonomics of typed code. Best of both worlds.

import { gui } from '@golemui/gui-shared';

export const signupForm = [
  gui.inputs.textInput('email', {
    label: 'Email',
    validator: { type: 'string', required: true, format: 'email' },
  }),
  gui.inputs.password('password', {
    label: 'Password',
    validator: { type: 'string', required: true, minLength: 8 },
  }),
  gui.inputs.dropdown('accountType', {
    label: 'Account type',
    items: ['Free', 'Pro', 'Enterprise'],
    defaultValue: 'Free',
    validator: { type: 'string', required: true },
  }),
  gui.inputs.numberInput('seats', {
    label: 'Seats',
    validator: { type: 'number', required: true, minimum: 5, maximum: 1000 },
    include: { when: '$form.accountType === "Enterprise"' },
  }),
  gui.inputs.checkbox('terms', {
    label: 'I accept the terms of service',
    validator: { type: 'boolean', const: true },
  }),
  gui.actions.button({ label: 'Sign up', onClick: 'submit' }),
];

Conditional fields, validation, accessibility, and i18n come built in. The exact same schema renders in React, Angular, Lit, or Vue. No useState, no register, no FormControl. The form is just a value you can pass around, save to a database, diff in a pull request, or send over the wire.

A pluggable engine

Here it helps to separate two things that share a name.

GolemUI is the engine: a framework-agnostic ecosystem for building forms. {gui.} is what we built on top of that engine, and what you get out of the box. The engine is the part you can take apart and rebuild to your taste.

Three layers

GolemUI follows the same three-layer pattern as other multi-framework libraries:

Core. Framework-agnostic, and where the thinking happens: state, reactivity, validation, and expressions.
Framework wrapper. Translates the core into each framework’s idioms, without tying it to any specific UI.
UI layer. A thin layer of pure framework code, where the actual user experience lives.

Bring your own (almost) anything

At its core, GolemUI is not a concrete implementation. It’s a collection of shapeless plugs waiting to be connected to their counterparts. There are a few restrictions, in the form of interfaces, but otherwise you’re free to bring your own:

BYOFWK (Bring Your Own Framework). We support React, Angular, Lit, and Vue first-class, and you can drive the engine from plain web components too. Need something else? Integrate your own framework by following our widget architecture.
BYOCS (Bring Your Own Component Set). Nothing stops you from implementing your own components. We did, and called it {gui.}. By following the same widget architecture, you can build a component set of your own.
BYOV (Bring Your Own Validators). GolemUI has a plug for validation, with one condition: your validators must implement the Standard Schema spec, like Zod, Valibot, and many others. Our own validators are built on Zod.
BYOi18n (Bring Your Own i18n). Integrate the i18n library of your choice through a simple adapter that maps any i18n system into the form engine, so you keep the advanced features those libraries are good at.
BYO*. And there’s more. middlewares let you intercept the reactivity engine, itemRenderers let you customize how list components render their children, and dependencies let components configure their own internals (our markdown component picks its parser this way).

`{gui.}`: batteries included

GolemUI on its own is a powerful engine waiting to be plugged into. {gui.} is what happens when we plug all of it in ourselves.

It ships with more than 30 widget types out of the box: inputs (text, select, date pickers, currency, and more), actions, display elements, and layout primitives like flex, grid, tabs, and accordion. You configure a form one of two interchangeable ways: write serializable JSON directly, or use the typed {gui.} builder and let it produce the JSON for you.

And three things every form needs are already done for you:

Accessibility, by default. Every component is WCAG 2.1 AA: keyboard navigation, semantic HTML, and ARIA managed for you. Accessible forms without writing a single line of accessibility code, on every framework.
Internationalization. Bring your own i18n library through a simple adapter. Translate labels, hints, and validation messages, switch languages live, and get automatic RTL support.
Validation. Schema-driven and Standard Schema compliant, with built-in rules, your own custom validators, localized error messages, and smart timing.

Built for humans and machines

This is the part we’re most excited about, because it’s where the “forms as data” idea really pays off.

A small, typed, data-first format isn’t only nice for people to read. It’s exactly the kind of thing a machine can emit cleanly. The signup form above is 35 lines and roughly 40% fewer tokens than the equivalent React Hook Form version, which means an agent can generate it reliably and your team can review it at a glance. Same code, both jobs.

So we leaned into it:

An MCP server. @golemui/gui-mcp gives AI coding assistants (Claude Code, Cursor, Windsurf, and others) deterministic form generation and validation, not guesswork. The model generates a form, then validates it against bundled schemas, in a tight generate-then-check loop.
Documentation for LLMs. Alongside the human docs, we ship llms-gui-dx.txt: a self-sufficient DX reference an AI form builder can read once and write a whole form from.
Form Studio. An AI-assisted, low-code form builder, available as a free open-source community edition that runs on Cloudflare Workers and needs only an Anthropic API key, plus a hosted Pro edition at studio.golemui.com with accounts, passkey auth, and storage.

Developers and machines, working on the same format.

The proof

The signup form above, measured. Tokens counted with cl100k_base:

35 lines vs 76 with React Hook Form

0 branches conditions live in the schema, not in code

366 tokens ~40% fewer than RHF (622)

And the runtime numbers:

14.32 kB gzipped library weight

0.19 ms LCP largest contentful paint

100 Lighthouse performance score

This is step one

v1 is a milestone, not a destination. It’s the first step in a larger vision of how forms and UIs should be built today and tomorrow, where developers and machines collaborate closely to implement the next billion apps . Forms as data, generatable and reviewable by both, is the foundation. There’s a lot more coming, and we’ll be writing about it here.

GolemUI v1.0.0 is MIT licensed and available now. If you’re at DevBcn 2026 in Barcelona on June 16-17, come say hello. We’d love to show you what we’ve built.

Try GolemUI now: Get started - Documentation - How it works - GitHub.