Conform: progressive enhancement for React forms that survive without JavaScript

The problem Conform solves: forms that break when the network is slow or JavaScript is missing

Most React form libraries assume the browser will run your JavaScript. That assumption holds in a demo and fails often enough in production that the failure is worth designing around. A form built on client-only state renders empty or unresponsive when a bundle fails to parse, when a corporate proxy strips a script, or when a user opens the page before hydration finishes. Conform takes the opposite starting point. The README describes the project as a way to "progressively enhance HTML forms with React" and lists "Progressive enhancement first design" as a feature. In practice this means the form is a real HTML form element that posts to a real URL, and the React layer adds client-side validation and error display on top rather than replacing the submission path. The audience is React developers working in Remix, Next.js, React Router or a plain single-page app who want schema-driven validation without giving up native form submission. The repository ships a separate example folder for each of those environments, which tells you the maintainers treat them as distinct targets rather than one abstraction stretched thin.

How Conform maps a schema onto form fields

The mechanism that carries the library is schema field inference. You write a validation schema once, and Conform derives the field names and the types of the values your form code receives. The README lists "Full type safety with schema field inference" and "Standard Schema support with enhanced Zod and Valibot integration" as features, and the workspace contains separate packages for Zod, Yup and Valibot alongside a DOM package and a React package. That split matters for evaluation: the validation backends are pluggable, so the choice of Zod versus Valibot is not baked into the core. Because the schema is the single source of truth, the same definition produces a server-side check and a client-side check, and the error messages you render come from the same place that rejects the submission. The trade-off is that the schema becomes a hard dependency of your form's shape. If you want a field whose validation rules do not fit a schema you can express, you are working against the design rather than with it. The documentation site covers nested objects and arrays separately, which suggests the maintainers consider complex structures a distinct problem area rather than a free consequence of the schema approach.

Installing Conform and wiring a first form

The README does not contain installation commands. It points to https://conform.guide for the overview and tutorial, and the repository's package.json shows the packages are named under the @conform-to scope, with @conform-to/react, @conform-to/dom, @conform-to/zod, @conform-to/yup and @conform-to/validitystate present as workspace dependencies. Install the React package plus the validation adapter for the schema library you use:

pnpm add @conform-to/react @conform-to/zod

The repository is a pnpm workspace and pins [email protected] in the packageManager field, so pnpm is the package manager the maintainers exercise. The project's own development scripts are a useful reference if you want to run the examples locally rather than read them:

pnpm install
pnpm dev:playground

That second command runs the playground workspace. There is no documented flag for pointing the playground at your own app, so treat it as a way to observe the library's behaviour, not as a scaffold generator. For a real integration, copy the structure from the example folder matching your framework. The examples directory contains nextjs, remix, react-router, react-spa, astro and a set of UI-library variants including shadcn-ui, radix-ui, material-ui, chakra-ui, react-aria, headless-ui, base-ui and shadcn-base-ui. Each is a working project rather than a snippet, which is the most reliable way to see how the submission helper is wired for that framework's request object.

Where Conform is the wrong choice

Conform is built around server-side submission. If your form never posts anywhere, if it is a client-side filter panel or a wizard whose state lives entirely in memory, the progressive enhancement machinery buys you nothing and you carry the schema inference cost for no benefit. A state-management-oriented form library will be less friction for that case. The second limitation is documentation coverage. The README is a landing page, not a reference: it lists feature bullets and links out to five documentation pages covering validation, complex structures, UI integrations, intent buttons and accessibility. Anything not covered by those pages lives in the repository or nowhere. There is no changelog in the README, though the repository uses Changesets and has a .changeset directory, so release notes are generated per pull request rather than written as a narrative. If you need a library with a single comprehensive manual, this is not it. A third consideration is version churn: three releases landed within the three weeks before the last push on 2026-09-28, at v1.20.2, v1.21.0 and v1.21.1. Frequent patch releases are normal for a maintained library, but they mean you should pin a version and read the changeset before upgrading rather than tracking the latest tag in production.

Conform compared with React Hook Form

React Hook Form is the obvious alternative and the difference is architectural, not cosmetic. React Hook Form keeps field state in an uncontrolled registry and reads values from the DOM at submit time, which keeps re-renders low and makes it a good fit for large forms in a client-rendered app. Conform inverts the emphasis: the HTML form is the submission mechanism, and the library's job is to keep that mechanism correct while adding validation on top. That is why the README can claim "Native Server Actions support for Remix and Next.js" as a feature; the library is designed for frameworks where a form post is a first-class server operation. The practical consequence is that Conform's value scales with how much of your application runs on the server. In a Remix or Next.js App Router project where mutations go through actions, Conform aligns with the framework's own model. In a pure client-side SPA with an API layer, React Hook Form's model matches the architecture more directly. Neither is better in the abstract, and the examples directory shipping a react-spa entry alongside nextjs and remix shows Conform is usable in both, just with less of its design pulling in your favour.

Maintenance, licence and upgrade cost

The repository is not archived and the last push was on 2026-09-28, so the project is being worked on. The most recent release listed is v1.21.1 from 2026-08-18, following v1.21.0 on 2026-08-09 and v1.20.2 on 2026-07-29. That cadence is regular enough that you should expect to review changesets rather than treat the library as frozen. The licence is MIT, stated in the README, in the repository's package.json and in the LICENSE file at the top level. MIT permits commercial use and modification with attribution and no warranty, which is permissive enough for most products; the usual caveat applies that this is a description of the licence text, not legal advice, and your organisation's policy on dependency licences is the thing that decides. Upgrade cost concentrates in the validation adapters. Because Zod, Yup and Valibot integrations are separate packages, a breaking change in one schema library does not force a change in the others, but it does mean you may need to wait for the matching adapter to be published before you can move that dependency. The workspace pins zod ^3.25.75 and yup ^0.32.11 as development dependencies, which tells you which major lines the maintainers are testing against.

Editorial conclusion

Adopt Conform if your forms must submit and validate correctly when JavaScript fails, and if you already use Zod, Valibot or Yup and want the schema to drive field names and error messages. Do not adopt it if your forms never submit to a server, or if you need a field-state model that survives arbitrary client-side transformations without a schema. Before committing, verify two things in a scratch project: that your chosen integration package resolves under your React version, and that your server framework exposes the request the way the submission helper expects. The repository's examples directory is the fastest way to check the second point, because it ships a separate example for each supported framework rather than one generic sample.

Frequently asked questions

Official sources

1. edmundhung/conform on GitHub
2. License: MIT
3. Project website
4. README
5. Releases