arktype vs io-ts vs joi vs runtypes vs superstruct vs yup vs zod
Runtime Type Validation and Schema Definition in TypeScript
Search packages..
arktypeio-tsjoiruntypessuperstructyupzodSimilar Packages:

Runtime Type Validation and Schema Definition in TypeScript

These libraries provide tools for defining data schemas and validating data at runtime, bridging the gap between static TypeScript types and dynamic JavaScript values. While TypeScript ensures type safety during development (compile-time), these packages ensure that data received from APIs, forms, or databases matches expected structures when the code actually runs. They differ significantly in syntax style, TypeScript integration depth, error handling capabilities, and bundle footprint. Some focus on developer experience with concise syntax, others on functional purity, and some on legacy compatibility or specific ecosystem integration.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
arktype07,853337 kB2632 months agoMIT
io-ts06,810460 kB1612 years agoMIT
joi021,1781.89 MB1992 days agoBSD-3-Clause
runtypes02,699371 kB2522 days agoMIT
superstruct07,131182 kB1042 years agoMIT
yup023,672270 kB252a year agoMIT
zod043,8335.8 MB576 days agoMIT

Runtime Validation Showdown: Choosing the Right Schema Library for TypeScript

In modern frontend development, TypeScript handles type safety while you write code, but it disappears once your code is compiled to JavaScript. This leaves a gap: how do you ensure the data coming from an API, a user form, or a local storage item actually matches your expected types? This is where runtime validation libraries step in. They act as a security guard at the door, checking data before it enters your application logic.

We are comparing seven major players: arktype, io-ts, joi, runtypes, superstruct, yup, and zod. While they all solve the same core problem, their approaches to syntax, type inference, and error handling vary wildly. Let's dive into how they handle real-world scenarios.

📝 Defining Schemas: Syntax and Readability

The first thing you notice is how you define what your data should look like. Some libraries feel like writing TypeScript; others feel like writing configuration files.

zod uses a chainable, object-based API that feels very natural to JavaScript developers. It reads almost like English.

import { z } from 'zod';

const UserSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
  role: z.enum(['admin', 'user'])
});

yup is very similar to zod but uses a slightly different chaining style, historically popular in the React form ecosystem.

import * as yup from 'yup';

const UserSchema = yup.object({
  id: yup.number().required(),
  name: yup.string().required(),
  email: yup.string().email().required(),
  role: yup.string().oneOf(['admin', 'user']).required()
});

runtypes aims to mirror TypeScript syntax as closely as possible. If you know TS, you basically know runtypes.

import { Record, Number, String, Union } from 'runtypes';

const UserSchema = Record({
  id: Number,
  name: String,
  email: String,
  role: Union('admin', 'user')
});

superstruct focuses on simplicity and uses a clean, functional definition style.

import { object, number, string, enums } from 'superstruct';

const UserSchema = object({
  id: number(),
  name: string(),
  email: string(),
  role: enums(['admin', 'user'])
});

arktype takes a completely different approach. It uses a string-based DSL (Domain Specific Language) to define types, which results in extremely concise code.

import { type } from 'arktype';

// Defines the same schema in a single string
const UserSchema = type({
  id: 'number',
  name: 'string',
  email: 'string.email',
  role: '"admin" | "user"'
});

io-ts leans heavily into functional programming. You compose types using functions, which can feel verbose but offers immense power for complex compositions.

import * as t from 'io-ts';

const UserSchema = t.type({
  id: t.number,
  name: t.string,
  email: t.string,
  role: t.union([t.literal('admin'), t.literal('user')])
});

joi uses a fluent interface that is very expressive but exists primarily in the JavaScript world without native TS type inference.

import Joi from 'joi';

const UserSchema = Joi.object({
  id: Joi.number().required(),
  name: Joi.string().required(),
  email: Joi.string().email().required(),
  role: Joi.string().valid('admin', 'user').required()
});

🔍 Parsing and Error Handling

Defining the schema is only half the battle. You need to parse incoming data and handle cases where the data is wrong. The way these libraries report errors can make or break your debugging experience.

zod provides a safeParse method that returns an object indicating success or failure. The error object is structured and easy to traverse.

const result = UserSchema.safeParse({ id: 'not-a-number', name: 'Alice' });

if (!result.success) {
  // result.error.issues contains a detailed list of problems
  console.log(result.error.issues[0].message); 
  // Output: "Expected number, received string"
}

yup uses an async validate method that throws an error if validation fails. You typically catch this error to get messages.

try {
  await UserSchema.validate({ id: 'not-a-number', name: 'Alice' });
} catch (err) {
  // err.message contains the first error found
  console.log(err.message); 
}

superstruct also throws on failure but provides a structured error object with path information.

import { assert } from 'superstruct';

try {
  assert({ id: 'not-a-number', name: 'Alice' }, UserSchema);
} catch (err) {
  // err.failures() returns an iterable of failure details
  console.log(Array.from(err.failures())[0].message);
}

runtypes uses a check or validate method. If it fails, it throws a specific ValidationError.

try {
  UserSchema.check({ id: 'not-a-number', name: 'Alice' });
} catch (err) {
  // err.message describes the failure
  console.log(err.message);
}

arktype returns a result object similar to zod but optimized for performance. It distinguishes between successful data and error details clearly.

const result = UserSchema({ id: 'not-a-number', name: 'Alice' });

if (result.incomplete) {
  // result.missing or result.typeErrors provide details
  console.log(result.typeErrors[0].message);
}

io-ts returns an Either type (a functional pattern). You must handle both the "Left" (error) and "Right" (success) cases explicitly.

import { decode } from 'io-ts';
import { isLeft } from 'fp-ts/Either';

const result = decode(UserSchema, { id: 'not-a-number', name: 'Alice' });

if (isLeft(result)) {
  // result.left contains the validation errors
  console.log(result.left[0].message);
}

joi uses an async validate method that returns an object with an error property if things go wrong.

const { error, value } = UserSchema.validate({ id: 'not-a-number', name: 'Alice' });

if (error) {
  // error.message gives the description
  console.log(error.message);
}

🛡️ TypeScript Inference: Static vs. Runtime

This is the most critical differentiator for TypeScript developers. Some libraries automatically generate TypeScript types from your schema, while others require you to define types twice.

zod, runtypes, and arktype excel here. You define the schema once, and the library infers the TypeScript type automatically.

// Zod Example
const UserSchema = z.object({ name: z.string() });
type User = z.infer<typeof UserSchema>; // Type is { name: string }

// Runtypes Example
const UserSchema = Record({ name: String });
type User = Static<typeof UserSchema>; // Type is { name: string }

// Arktype Example
const UserSchema = type({ name: 'string' });
type User = typeof UserSchema.infer; // Type is { name: string }

superstruct requires a slightly more manual approach using generics to extract the type.

const UserSchema = object({ name: string() });
type User = Infer<typeof UserSchema>; // Requires importing Infer helper

io-ts requires you to use the TypeOf utility from the library to extract the static type.

const UserSchema = t.type({ name: t.string });
type User = t.TypeOf<typeof UserSchema>;

yup can infer types, but it often requires explicit generic arguments or helper functions to work reliably in complex scenarios.

const UserSchema = yup.object({ name: yup.string() });
type User = yup.InferType<typeof UserSchema>;

joi does not infer TypeScript types natively. You must define your interface separately and hope it stays in sync with your schema, or use third-party bridges.

// Manual definition required - risk of drift!
interface User {
  name: string;
}
// Schema is defined separately with no automatic link
const UserSchema = Joi.object({ name: Joi.string() });

🏗️ Advanced Patterns: Refinements and Unions

Real-world data is messy. You often need to validate logic that goes beyond simple types, like ensuring a password is strong or handling different shapes of data based on a "type" field.

zod handles refinements (custom logic) and discriminated unions very elegantly.

// Refinement: Password must be > 8 chars
const PasswordSchema = z.string().refine(val => val.length > 8, 'Too short');

// Discriminated Union: Cat vs Dog
const PetSchema = z.discriminatedUnion('kind', [
  z.object({ kind: z.literal('cat'), meow: z.boolean() }),
  z.object({ kind: z.literal('dog'), bark: z.boolean() })
]);

yup supports custom tests for refinements but can get verbose with complex unions.

// Refinement
const PasswordSchema = yup.string().test('len', 'Too short', val => val.length > 8);

// Union (less type-safe)
const PetSchema = yup.mixed().oneOf([catSchema, dogSchema]);

superstruct uses the refine function and union for these cases.

// Refinement
const PasswordSchema = refine(string(), 'password', s => s.length > 8);

// Union
const PetSchema = union([CatSchema, DogSchema]);

io-ts uses combinators like refinement and taggedUnion, which are powerful but verbose.

// Refinement
const PasswordSchema = t.refinement(t.string, 'Password', s => s.length > 8);

// Tagged Union
const PetSchema = t.taggedUnion('kind', [CatSchema, DogSchema]);

runtypes uses .withConstraint for refinements and Union for variants.

// Refinement
const PasswordSchema = String.withConstraint(s => s.length > 8 || 'Too short');

// Union
const PetSchema = Union(CatSchema, DogSchema);

arktype handles logic directly within its string syntax or via methods.

// Refinement in syntax
const PasswordSchema = type('string > 8'); 

// Union
const PetSchema = type({ kind: '"cat"', meow: 'boolean' }).or({ kind: '"dog"', bark: 'boolean' });

joi uses .custom for logic and .alternatives for unions.

// Refinement
const PasswordSchema = Joi.string().custom((val, helpers) => {
  if (val.length <= 8) return helpers.error('any.invalid');
  return val;
});

// Alternatives
const PetSchema = Joi.alternatives().try(CatSchema, DogSchema);

🚦 Deprecation and Maintenance Status

It is crucial to note the maintenance status of these libraries before investing time.

  • joi: While still widely used in legacy Node.js backends, it is NOT recommended for new frontend TypeScript projects. It lacks native type inference, which defeats the purpose of using TypeScript. Its bundle size is also significantly larger than modern alternatives.
  • yup: Still maintained and the king of form validation (especially with Formik), but for general-purpose API validation, zod has largely superseded it due to better TS inference and smaller size.
  • io-ts: Actively maintained but niche. Only choose this if you are all-in on functional programming.
  • arktype, zod, runtypes, superstruct: All actively maintained and excellent choices for modern development.

💡 Final Recommendation

For most professional frontend teams starting a new project today, zod is the default winner. It offers the best balance of developer happiness, powerful TypeScript inference, and ecosystem support. It just works.

If you are building highly performance-critical applications where bundle size is the #1 constraint, look closely at arktype. Its string syntax is weird at first, but the speed gains are real.

If you are deep in the React forms world, yup remains a strong contender specifically for form validation, though zod is catching up fast there too with adapters.

Avoid joi for new TypeScript work unless you are forced to by legacy constraints. The lack of automatic type inference creates too much friction and risk of bugs in a strictly typed environment.

Choose the tool that fits your team's mental model, but remember: the goal is to catch errors early, not to fight with your validation library.

How to Choose: arktype vs io-ts vs joi vs runtypes vs superstruct vs yup vs zod

  • arktype:

    Choose arktype if you need the absolute smallest bundle size and fastest validation speed without sacrificing TypeScript inference. It uses a unique string-based syntax that is incredibly concise, making it ideal for high-performance applications or environments where every kilobyte counts. However, be aware that its syntax is non-standard and may require a learning curve for teams used to object-based schemas.

  • io-ts:

    Choose io-ts if your team heavily relies on functional programming patterns and the fp-ts ecosystem. It treats validators as first-class functional combinators, offering rigorous type safety and composability. It is best suited for complex domains where mathematical correctness and immutability are priorities, though it often requires more boilerplate and a deeper understanding of functional concepts than other options.

  • joi:

    Choose joi primarily for maintaining legacy Node.js backends or if you specifically need its powerful, fluent API for complex nested object validation outside of TypeScript. Note that joi is generally NOT recommended for new frontend TypeScript projects because it relies on runtime JavaScript logic that does not automatically infer static TypeScript types, requiring extra tools like @hapi/joi-to-typescript to bridge the gap.

  • runtypes:

    Choose runtypes if you value readability and want your validation logic to look exactly like TypeScript type definitions. It uses a very intuitive, object-like syntax that maps directly to TS types, making it easy for developers to read and write. It is a solid middle-ground choice for teams that want strong typing without adopting functional programming paradigms or learning a new DSL.

  • superstruct:

    Choose superstruct if you need a lightweight, zero-dependency library that focuses on simplicity and custom error messages. It strikes a balance between feature richness and ease of use, making it great for applications that need robust validation but don't require the heavy type-level magic of zod or io-ts. Its API is straightforward and predictable, ideal for standard CRUD applications.

  • yup:

    Choose yup if you are building forms with formik or react-hook-form, as it has deep, first-class integration with these libraries. It offers a fluent, chainable API that is easy to read and write, making it a favorite for form validation scenarios. While it supports TypeScript, its type inference is generally considered less powerful and robust compared to zod or runtypes for general-purpose data parsing.

  • zod:

    Choose zod as the default modern standard for most TypeScript projects requiring schema validation. It offers the best balance of developer experience, powerful TypeScript inference, and a rich ecosystem of plugins. Its API is intuitive, its error messages are helpful, and it handles complex scenarios like discriminated unions and refinements effortlessly. It is the safest bet for new projects unless you have specific constraints requiring another tool.

Similar Npm Packages to arktype

arktype is a TypeScript-first validation library that allows developers to define and validate data structures in a concise and expressive manner. It focuses on providing a simple API for runtime type validation while leveraging TypeScript's type system for compile-time safety. This makes it an excellent choice for developers looking to ensure data integrity in their applications with minimal boilerplate code. While arktype offers a robust solution for data validation, there are several alternatives in the ecosystem that also provide similar functionality. Here are a few noteworthy options:

  • io-ts is a runtime type system for IO decoding and validation in TypeScript. It allows developers to define complex data structures and validate them at runtime. io-ts is particularly useful for working with external data sources, such as APIs, where data may not always conform to expected types. Its integration with functional programming concepts makes it a powerful choice for developers who prefer a more functional approach to data validation.
  • joi is a popular schema description language and data validator for JavaScript. It provides a rich set of features for defining complex validation rules and is widely used in Node.js applications. joi is known for its expressive syntax and powerful validation capabilities, making it suitable for both server-side and client-side validation scenarios. If you need a comprehensive validation library that can handle various data types and structures, joi is a solid option.
  • runtypes is a library for runtime type checking in TypeScript. It allows developers to define types and validate data against those types at runtime. runtypes is lightweight and straightforward, making it easy to integrate into existing TypeScript projects. If you are looking for a simple and effective way to perform runtime type validation without a lot of overhead, runtypes is worth considering.
  • superstruct is a library for creating and validating complex data structures in JavaScript and TypeScript. It provides a simple API for defining structures and validating data against them. superstruct is designed to be lightweight and flexible, making it easy to use in various applications. If you need a validation library that is easy to set up and use, superstruct is a great choice.
  • yup is a JavaScript schema builder for value parsing and validation. It is particularly popular in the React ecosystem, often used with form libraries like Formik. yup provides a fluent API for defining validation schemas and is known for its ease of use and integration with other libraries. If you are building forms and need a validation library that works seamlessly with React, yup is an excellent option.
  • zod is a TypeScript-first schema declaration and validation library. It provides a simple and intuitive API for defining schemas and validating data against them. zod is designed to be lightweight and focused on TypeScript, making it a great choice for developers who want to leverage TypeScript's type system for runtime validation.

To explore how arktype compares with io-ts, joi, runtypes, superstruct, yup, and zod, check out the comparison: Comparing arktype vs io-ts vs joi vs runtypes vs superstruct vs yup vs zod.

Similar Npm Packages to io-ts

io-ts is a TypeScript library for runtime type validation and decoding. It allows developers to define types using a functional approach and validate data at runtime, ensuring that the data conforms to the specified types. This is particularly useful in scenarios where data comes from external sources, such as APIs, and needs to be validated before use. io-ts integrates seamlessly with TypeScript, providing strong type inference and ensuring type safety throughout your application.

While io-ts offers a robust solution for runtime type validation, there are several alternatives in the ecosystem that also provide similar functionality. Here are a few noteworthy options:

  • joi is a powerful schema description language and data validator for JavaScript objects. It allows developers to create complex validation rules and provides a rich set of features for validating and sanitizing data. joi is widely used in Node.js applications and is known for its expressive syntax and flexibility. If you are looking for a comprehensive validation library that can handle complex validation scenarios, joi is an excellent choice.

  • runtypes is a library for creating runtime type checkers in TypeScript. It allows developers to define types and validate data against those types at runtime. runtypes is designed to be simple and lightweight, making it easy to integrate into existing TypeScript projects. If you prefer a minimalistic approach to runtime type validation while still leveraging TypeScript's type system, runtypes is worth considering.

  • zod is a TypeScript-first schema declaration and validation library. It provides a simple and intuitive API for defining schemas and validating data, with a strong focus on TypeScript support. zod allows developers to create complex validation rules while maintaining type safety, making it a great choice for TypeScript applications. If you want a library that is easy to use and integrates well with TypeScript, zod is a strong contender.

To see how io-ts compares with joi, runtypes, and zod, check out the comparison: Comparing io-ts vs joi vs runtypes vs zod.

Similar Npm Packages to joi

joi is a powerful schema description language and data validator for JavaScript objects. It allows developers to define complex validation rules for their data structures, making it easier to ensure that incoming data meets specific criteria before processing it. Joi is particularly useful in server-side applications, where data validation is crucial for maintaining data integrity and security. While joi is a popular choice for data validation, there are several alternatives available in the ecosystem. Here are a few notable ones:

  • celebrate is a middleware for Express.js that integrates Joi for validating request data. It allows developers to define validation schemas for request parameters, query strings, and request bodies, making it easy to enforce data integrity in Express applications. Celebrate simplifies the validation process by providing a straightforward API that works seamlessly with Express, ensuring that only valid data reaches your route handlers. If you're already using Joi and want to integrate it into your Express application, Celebrate is an excellent choice.
  • express-validator is another popular middleware for validating and sanitizing request data in Express applications. Unlike Joi, which focuses on schema-based validation, express-validator uses a set of validation and sanitization middlewares that can be applied to individual routes. This flexibility allows developers to define validation rules directly in their route definitions. If you prefer a more modular approach to validation and want to keep your validation logic close to your route handlers, express-validator is a great alternative.
  • yup is a JavaScript schema builder for value parsing and validation. It is similar to Joi but offers a more modern API and is often favored for its promise-based validation and support for asynchronous validation. Yup is particularly useful for client-side validation in React applications, but it can also be used in server-side contexts. If you're looking for a lightweight and flexible validation library that works well with both client and server applications, Yup is worth considering.

To explore how joi compares with celebrate, express-validator, and yup, check out the comparison: Comparing celebrate vs express-validator vs joi vs yup.

Similar Npm Packages to runtypes

runtypes is a TypeScript library designed for runtime type checking. It allows developers to define and validate the structure of data at runtime, ensuring that the data conforms to the expected types. This is particularly useful in scenarios where data is received from external sources, such as APIs, and helps catch errors early in the development process. While runtypes offers a robust solution for type validation, there are several alternatives in the ecosystem that provide similar functionality. Here are a few notable alternatives:

  • io-ts is a runtime type system for IO decoding and validation in TypeScript. It allows developers to define complex types and validate data against those types at runtime. With its functional programming approach, io-ts provides a powerful way to handle type validation, including support for union types, intersection types, and more. If you are looking for a library that integrates well with functional programming paradigms and offers extensive type validation capabilities, io-ts is a strong candidate.

  • joi is a popular schema description language and data validator for JavaScript. It provides a rich set of features for defining complex validation rules and is widely used in Node.js applications. joi allows developers to create schemas that can validate various data types, including objects, arrays, and strings. If you need a comprehensive validation library with a mature ecosystem and extensive documentation, joi is an excellent choice.

  • superstruct is a simple and composable way to validate data in JavaScript and TypeScript. It allows developers to define structures and validate data against those structures using a straightforward API. superstruct is lightweight and easy to use, making it a great option for projects that require basic validation without the overhead of more complex libraries.

  • yup is a JavaScript schema builder for value parsing and validation. It is particularly popular in the React ecosystem, especially when used with form libraries like Formik. yup provides a fluent API for defining schemas and supports asynchronous validation, making it a versatile choice for handling form validation in web applications.

  • zod is a TypeScript-first schema declaration and validation library. It is designed to be simple and intuitive, allowing developers to define schemas using a straightforward syntax. zod is particularly useful for TypeScript users who want to leverage type inference and ensure that their data structures are validated at runtime.

To explore how runtypes compares with io-ts, joi, superstruct, yup, and zod, check out the comparison: Comparing io-ts vs joi vs runtypes vs superstruct vs yup vs zod.

Similar Npm Packages to superstruct

superstruct is a library for validating and structuring data in JavaScript and TypeScript applications. It provides a simple and expressive way to define data structures and validate data against those structures. With its lightweight and flexible design, superstruct allows developers to create complex validations while maintaining readability and ease of use. It is particularly useful for applications that require strict data validation and type checking.

While superstruct offers a robust solution for data validation, there are several alternatives in the ecosystem that also provide similar capabilities. Here are a few noteworthy options:

  • io-ts is a runtime type system for TypeScript that allows you to define and validate data structures. It leverages TypeScript's type system to provide type-safe validation, making it a great choice for TypeScript developers. io-ts is particularly useful when you need to validate data coming from external sources, such as APIs, while ensuring that your application remains type-safe. Its integration with TypeScript enables developers to catch type errors at compile time, enhancing overall code quality and maintainability.

  • joi is a powerful schema description language and data validator for JavaScript objects. It allows developers to create complex validation schemas with a rich set of built-in validators. joi is widely used in Node.js applications for validating request payloads, ensuring that incoming data adheres to specified formats and constraints. Its expressive syntax and comprehensive validation capabilities make it a popular choice for server-side validation.

  • yup is a JavaScript schema builder for value parsing and validation. It is similar to joi but is designed to work seamlessly with React and other frontend frameworks. yup provides a fluent API for defining schemas and supports asynchronous validation, making it suitable for form validation in web applications. Its integration with popular libraries like Formik enhances the developer experience when handling form state and validation.

To see how superstruct compares with io-ts, joi, and yup, check out the comparison: Comparing io-ts vs joi vs superstruct vs yup.

Similar Npm Packages to yup

yup is a JavaScript schema builder for value parsing and validation. It is often used in conjunction with form libraries to ensure that user input meets certain criteria before being processed. Yup provides a fluent API for defining schemas, making it easy to validate complex data structures. While yup is a popular choice for validation, there are several alternatives available in the JavaScript ecosystem. Here are a few notable ones:

  • express-validator is a set of middleware functions that can be used to validate and sanitize user input in Express.js applications. It is built on top of validator.js and provides a simple way to validate request data, such as query parameters, body data, and headers. If you're working with an Express application and need to validate incoming requests, express-validator is a robust solution that integrates seamlessly with the Express framework.
  • joi is another powerful schema description language and data validator for JavaScript. It allows developers to create complex validation rules and provides a rich set of features for validating various data types. Joi is particularly useful for server-side validation in Node.js applications, and it can be used to validate incoming request data as well as data from other sources. If you need a comprehensive validation library that supports complex validation scenarios, joi is an excellent option.
  • validator.js is a library that provides a set of string validators and sanitizers. While it does not offer the same schema-based validation approach as yup, joi, or express-validator, it can be used in conjunction with other libraries to perform basic validation tasks. If you need lightweight validation functions for specific use cases, validator.js can be a useful addition to your toolkit.

For a detailed comparison of these validation libraries, check out the following link: Comparing express-validator vs joi vs yup.

Similar Npm Packages to zod

zod is a TypeScript-first schema declaration and validation library. It allows developers to define schemas for their data structures and validate data against these schemas in a type-safe manner. Zod is particularly useful for ensuring that the data conforms to expected formats, making it a great choice for applications that require robust data validation. While Zod offers a powerful solution for schema validation, there are several alternatives in the ecosystem that provide similar functionalities. Here are a few notable alternatives:

  • io-ts is a runtime type system for TypeScript that allows you to define types and validate data at runtime. It provides a functional approach to validation and can be integrated with other libraries like fp-ts for functional programming paradigms. io-ts is particularly useful for applications that require both static type checking and runtime validation, making it a solid choice for developers who prioritize functional programming principles.

  • joi is a powerful schema description language and data validator for JavaScript objects. It provides a rich set of features for defining complex validation rules and is widely used in Node.js applications. Joi's expressive syntax allows developers to create detailed validation schemas with ease. If you are looking for a mature and feature-rich validation library that works well in both client-side and server-side applications, joi is an excellent option.

  • yup is a JavaScript schema builder for value parsing and validation. It is heavily inspired by Joi but is designed to work seamlessly with React and other modern JavaScript frameworks. Yup provides a simple and intuitive API for defining validation schemas and supports asynchronous validation. If you are building applications with React and need a validation library that integrates well with form libraries like Formik, yup is a great choice.

To see how zod compares with io-ts, joi, and yup, check out the comparison: Comparing io-ts vs joi vs yup vs zod.

README for arktype

ArkType

TypeScript's 1:1 validator, optimized from editor to runtime

ArkType is a runtime validation library that parses optimized validators from familiar, type-safe syntax.

It can be used to check external data like JSON payloads or forms at the boundaries of your code (similar to Zod).

Docs

See our docs site

Contributions

We accept and encourage pull requests from outside ArkType. Planned work is tracked in this GitHub project.

Depending on your level of familiarity with type systems and TS generics, some parts of the codebase may be hard to jump into. That said, there's plenty of opportunities for more straightforward contributions. We'd generally recommend starting with one of these issues labeled external-contributor-friendly.

If you're planning on submitting a non-trivial fix or a new feature, please create an issue first so everyone's on the same page. The last thing we want is for you to spend time on a submission we're unable to merge.

When you're ready, check out our guide to get started!

License

This project is licensed under the terms of the MIT license.

Code of Conduct

We will not tolerate any form of disrespect toward members of our community. Please refer to our Code of Conduct and reach out to david@arktype.io immediately if you've seen or experienced an interaction that may violate these standards.

Sponsorship

We've been working full-time on this project for multiple years and it means a lot to have the community behind us.

If the project has been useful to you and you are in a financial position to do so, please chip in via GitHub Sponsors.

Otherwise, consider sending me an email (david@arktype.io) or message me on Discord to let me know you're a fan of ArkType. Either would make my day!

ArkSponsors ⛵

mintlifyget-convexinspatiallabssam-goodwin

Sponsors 🥰

tmmmewhhahajahandsdrwpwrsPhalangers
WilliamConnatserJameEndertylim88
npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.