@rjsf/core

@rjsf/core is the base engine of react-jsonschema-form (RJSF), a React component that generates complete, validated web forms directly from a JSON Schema definition rather than hand-written JSX. It resolves the schema into fields, widgets, and layout templates at render time, wiring in validation, conditional logic (if/then/else, oneOf/anyOf), and array/object nesting automatically.

Rather than shipping its own visual style, @rjsf/core exposes a themeable registry that every other RJSF package — @rjsf/mui, @rjsf/antd, @rjsf/chakra-ui, @rjsf/shadcn, and more — builds on top of, along with @rjsf/utils for shared schema-resolution helpers and @rjsf/validator-ajv8 for AJV-based validation. It’s the common core the whole rjsf-team monorepo is organized around.

What You Get

• A Form component that renders inputs, selects, checkboxes, arrays, and nested objects directly from a JSON Schema, with no manual JSX per field
• A themeable registry (getDefaultRegistry, withTheme) that lets UI-kit packages like @rjsf/mui or @rjsf/antd swap in their own fields/widgets/templates
• Support for JSON Schema conditionals (if/then/else, oneOf, anyOf, allOf) and array/object nesting resolved automatically at render time
• A pluggable validator interface, most commonly filled by the companion @rjsf/validator-ajv8 package for AJV-based schema validation

Common Use Cases

• Generating admin/back-office CRUD forms directly from an API’s JSON Schema without hand-writing each field
• Building dynamic, schema-driven settings or configuration UIs that change shape as the underlying schema evolves
• Rendering multi-step or conditional forms where field visibility depends on other field values (if/then/else)
• Providing a consistent form-generation layer across multiple design systems by swapping the theme package while keeping the same schema

Under The Hood

Architecture — @rjsf/core’s Form component (packages/core/src/components/Form.tsx) is the orchestration layer: on each render it walks the JSON Schema, resolves $refs and combinators (allOf/anyOf/oneOf), and looks up the field/widget/template to use for each schema node from a registry object (built by getDefaultRegistry). The withTheme higher-order component is how theme packages (MUI, Ant Design, Chakra, shadcn, etc.) inject their own field/widget/template implementations without forking the core resolution logic — the theme only supplies UI primitives, while @rjsf/core supplies the schema-to-component mapping.

Tech Stack — TypeScript throughout (97.8% of the repo), built with esbuild for CJS/ESM bundles and Rollup for a UMD build, inside a pnpm-workspace monorepo shared with all theme packages. Actual JSON Schema validation is delegated to a pluggable validator interface rather than being baked into core — @rjsf/validator-ajv8 (AJV) is the reference implementation the monorepo ships and tests against.

Code Quality — Extensive Vitest test suite under packages/core/test/, with dedicated files per schema feature (allOf.test.tsx, anyOf.test.tsx, ArrayField.test.tsx, const.test.tsx, etc.) plus snapshot tests, giving very granular coverage of JSON Schema edge cases. Linting runs through oxlint/oxfmt, and lint-staged enforces formatting on commit; the monorepo’s 100+ tagged releases and steady commit cadence (30+ commits/month) reflect an actively maintained codebase.

API Design — The public API is intentionally minimal — a Form component taking schema, uiSchema, and validator props — which keeps the barrier to a working form very low, while withTheme/getDefaultRegistry give theme authors a clean, documented extension point instead of requiring a fork. The trade-off is that JSON Schema and UI Schema syntax themselves carry a learning curve, since the correctness of a form now depends on schema authoring rather than JSX.