Open source · Apache-2.0

An open-source form specification for high-stakes environments

Build complex forms
in an afternoon.
They work everywhere. Even offline.

Describe what you need in plain English. AI builds a working form — complete with business rules, smart defaults, and multi-page workflows. One definition renders on web, React, iOS, and Android. Works offline. No vendor lock-in.

Try Formspec Studio GitHub Docs

Rust TypeScript React Swift Kotlin Python WASM Web Components Tailwind USWDS JSON Schema MCP Server FHIR schema.org ICD-10 Field-level guidance i18n AI-native Apache-2.0

definition.json Preview

Live demo — edits on the left update this form in real time.

Live demo See a working form built with formspec-react — zero component overrides, default rendering Live demo Federal grant application rendered with the USWDS design system adapter

Formspec Studio Full form builder Visual editor for building, editing, and managing complex forms. Full control over every field and rule.

$ formspec-mcp

28 tools registered

MCP Server IDE & AI agent users 28 typed tools for AI-driven form authoring. Add to Claude, Cursor, or any MCP client.

git clone https://github.com/Formspec-org/formspec.git && cd formspec && npm i && npm run build

Claude Desktop

I need a grant application with budget tracking

Building form with 12 fields, 3 pages...

Chat AI-powered kickstart Describe what you need. AI builds a working form in minutes. No install, no IDE.

An open standard for complex forms —
not another form builder.

Formspec is a JSON-native specification that defines everything about a form: fields, validation, conditional logic, calculated values, page flow, output mapping, and contextual references. It's technology-agnostic — the same definition renders on the web (plain HTML or React), validates on a server, and runs natively on iOS and Android. AI agents can read it, write it, and verify it. Your developers implement it once; your team deploys it everywhere.

~100x faster

A 200-field form in 20 minutes, not 3 months

Traditional form development takes weeks to months — requirements, design, build, test, iterate. Describe what you need to the AI and get a working form with validation, conditional logic, and calculations in a single session.

Your applicants can't submit invalid budgets

Even on a plane. Same validation rules on every platform — web, React, iOS, Android, and server. Five runtimes, one set of rules.

Flag a $50,000 travel budget without blocking the submission

Your reviewer sees the warning. Your applicant keeps moving. Errors and warnings are distinct.

Submit once. Get the data in every format your systems need.

No re-entry. No export macros. The mapping engine handles transformation.

AI can't produce a form that breaks your rules

Every AI-generated form passes through the same validation as human-built forms. Three layers of checks catch errors before anything reaches your users.

WCAG 2.1 AA and Section 508 compliant out of the box

Accessibility is built into the behavior layer — ARIA, keyboard navigation, focus management, validation announcements. Every component, every adapter, every design system.

USWDS adapter included — bring any design system

Federal agencies get USWDS branding out of the box. The headless adapter architecture lets you plug in Bootstrap, Tailwind, Material, or your own system — same behavior, different DOM.

Built-in i18n — serve applicants in their language

Locale sidecar documents add translated labels, help text, and error messages to any form. Add a language by adding a file — never edit the original. Smart fallbacks mean no blank fields, even with partial translations.

Built for teams where forms are mission-critical.

Not contact forms. Not surveys. The kind where getting it wrong has consequences.

I want to stop waiting months for forms

I described our 200-field grant application to the AI. Twenty minutes later I had a working form with conditional sections, budget calculations, and validation rules. My team spent the afternoon reviewing it instead of the quarter building it.

Describe what you need in plain English. The AI builds it through structured tool calls — not guessing. Every field, every rule, every calculation goes through validation before you see it.
The system can't produce a form that breaks your rules. Three layers of automatic checks catch errors before anything reaches your applicants.
You stay in control. Review everything, tweak what you want, deploy when ready. AI handles the tedious parts — you make the decisions.

I manage a grant program

I need applicants to fill out complex forms that enforce our rules — and I need the data in three different formats for three different systems.

Calculated fields, conditional sections, required-field enforcement — all built into the form definition. No backend glue.
Collect once, output everywhere. Format transformation is built in.
Version-locked: mid-cycle rule changes never invalidate submitted responses.
Applicants get contextual help, regulatory references, and semantic autofill as they fill — so fewer support tickets and fewer abandoned forms.

I run field operations

My staff collect data in places with no cell signal — on phones, on tablets, sometimes on laptops. I need the forms to work offline and validate on sync.

Same form, same rules, no internet required. Runs natively on Android and iOS, or in the browser. Validation happens on-device, offline.
Warnings flag unusual values without blocking submission. Only hard errors stop the form.
Data syncs when connectivity returns — nothing lost.
Multi-language support (i18n) built in — locale documents add translated labels, help text, and error messages without modifying the form. Your staff see the form in their language; the data collected is identical.

I'm evaluating this for my agency

I need to know we can own this, maintain it, and it won't disappear when a vendor pivots.

Open source, Apache-2.0 runtime. Your form definitions are portable files you control — not data locked inside a vendor's platform.
WCAG 2.1 AA and Section 508 compliant. A USWDS adapter ships built-in for federal branding — or plug in any design system through the headless adapter architecture.
One form definition deploys to five runtimes: web, React, iOS, Android, and server. A response that passes in the field can be re-verified at headquarters — automatically.
Agent interoperability is spec-defined and LLM-optional. Browser extensions, accessibility tools, and automation scripts can fill forms through the same protocol — no AI vendor lock-in.

From description to deployment.

Describe

Tell the AI what your form needs. Fields, rules, calculations, page flow — in plain English.
Build

AI generates a complete form definition through typed tool calls. Every field and rule passes through validation automatically.
Review

You see the result instantly. Tweak anything — the AI handles boilerplate, you make the decisions.
Deploy

Your form runs on web, React, iOS, and Android — same definition, same validation, same behavior. No rebuilding per platform.

For developers

A specification, not a platform.

Self-hosted. Free forever. Apache-2.0 runtime.

The Specification

JSON-native form definitions validated by JSON Schema
FEL (Formspec Expression Language) — deterministic, side-effect-free expressions for calculations, conditions, and validation
Companion sidecars for references, ontology bindings, and locale translations — metadata that attaches without altering core behavior
Static linter catches definition errors before runtime

Five Runtimes

Rust shared kernel — single implementation of FEL, linting, evaluation, mapping, compiled to WASM and PyO3
TypeScript form engine — reactive signals, framework-agnostic, calls Rust via WASM for all pure logic
<formspec-render> web component — drop a tag, get a form. WCAG 2.1 AA and Section 508 compliant.
formspec-react — React hooks + auto-renderer. useField, granular subscriptions, overridable component map. Semantic HTML defaults.
formspec-swift (iOS/macOS) and formspec-kotlin (Android) — native renderers with Jetpack Compose and SwiftUI, same engine via hidden WebView bridge
Headless adapter architecture — USWDS ships built-in; plug in Bootstrap, Tailwind, Material, Shadcn, or your own design system
Python evaluator — server-side re-validation via PyO3, same Rust core, same results
Mapping engine — output transformation to any format

AI Integration

MCP server with 28 typed tools — AI agents build forms through structured calls, not freeform text generation
Automatic validation catches errors in AI-generated forms before they reach production
Formspec Studio — describe what you need, watch the AI build it in real time
Expression language is deterministic and verifiable — AI-generated logic can be audited

Formspec is the form engine — data, logic, validation, rendering. Hosting, auth, workflows — that's your stack.

    validate.py 
 # Server-side re-verification — same rules the browser ran
from formspec.fel import Evaluator
from formspec.validator import validate_response

# Load the definition that ran in the browser
evaluator = Evaluator(definition)
report = validate_response(evaluator, submitted_data)

if report.has_errors:
    return {"errors": report.results} 

    engine.ts 
 // Browser — reactive signals, live validation
import { FormEngine } from "@formspec-org/engine";

const engine = new FormEngine();
engine.setDefinition(definition);
engine.setValue("org_type", "nonprofit");

// Signals update — EIN field becomes relevant
const report = engine.getValidationReport();
const response = engine.getResponse(); 

    App.tsx 
 // React — hooks + auto-renderer with custom components
import { FormspecForm } from "@formspec-org/react";

// Drop in with defaults — semantic HTML, zero opinions
<FormspecForm definition={definition} />

// Or bring your own components
<FormspecForm
  definition={definition}
  components={{ fields: { TextInput: MyShadcnInput } }}
/> 

    index.html 
 <!-- Drop-in web component. No framework required. -->
<script type="module">
  import "@formspec-org/webcomponent";
</script>

<formspec-render></formspec-render>

<script>
  const el = document.querySelector("formspec-render");
  el.definition = myDefinition;
</script> 

    studio-session.mcp 
 // AI builds a grant application via MCP tool calls
formspec_field({ path: "org_name", label: "Organization Name", type: "string" })
formspec_field({ path: "budget", label: "Requested Amount", type: "decimal" })
formspec_group({ path: "line_items", label: "Budget Line Items",
  props: { repeat: { min: 1, max: 20 } } })
formspec_behavior({
  action: "add_rule", target: "budget",
  rule: "$budget > 0",
  message: "Budget must be positive"
})
formspec_flow({ action: "set_mode", mode: "wizard" }) 

Stop building forms by hand.

Describe what you need. AI builds it. Automatic validation makes sure it's right. One definition deploys to web, React, iOS, and Android. Open source, no vendor lock-in. Your team ships in days, not months.

Formspec Studio Visual editor for building, editing, and managing complex forms. Full control over every field, rule, and workflow.

MCP Server 28 typed tools that let AI agents build forms through structured tool calls. Add it to Claude Desktop or your IDE in 30 seconds.

Chat AI-powered kickstart. Describe what you need, get a working form in minutes. No install, no IDE.

Try Formspec Studio Install MCP Server View on GitHub Read the specification

Build complex forms in an afternoon. They work everywhere. Even offline.

An open standard for complex forms — not another form builder.