Open-source alternatives to Validator

This project is a Python implementation of the JSON Schema specification, providing a library for verifying that data instances conform to defined schemas. It serves as a data validation framework capable of validating both the data itself and the schemas against official meta-schemas to ensure structural correctness. The library features a schema reference resolver that maps URIs to definitions, enabling the resolution of internal and remote references for modular schema management. It is designed for extensibility, allowing for the definition of custom keywords, custom type-checking logic,

Angular schema form is a framework directive and form component library that automatically generates and validates interactive HTML form controls from standard JSON schemas and companion layout configurations. It translates structured data definitions into customizable user input interfaces, parsing data types and custom rules into native form controls and reusable HTML markup templates. The project provides capabilities for dynamic field management, allowing form elements to show or hide conditionally by evaluating expressions against current model and scope state, and supporting dynamic arr

mapstructure is a reflection-based library for the bidirectional encoding and decoding of generic map data into native typed Go structures. It functions as a tool for transforming loosely typed map values into specific structs and encoding those structs back into maps. The library utilizes Go reflection to map generic data keys to struct fields during runtime. It supports the transformation of untyped data from dynamic sources or configuration files into type-safe native structures. The mapping process includes recursive traversal of nested maps and slices, as well as the use of struct tags

envconfig is a Go configuration decoder and environment variable mapper that deserializes environment variables into structured Go data types. It provides tools for validating mandatory fields and ensuring application configuration adheres to the external configuration patterns of twelve-factor app compliance. The library features a help generator that creates formatted usage text based on struct definitions to describe expected environment variables. It also includes a validation tool capable of detecting unused environment variables that match a specific prefix but do not correspond to any

Backbone.validation is a JavaScript library designed to enforce data integrity within Backbone.js models. It provides a framework for defining declarative validation schemas that intercept attribute changes, ensuring that data meets specified business requirements before it is committed to the model. The library distinguishes itself by tightly coupling model-level validation with user interface components. It features an event-driven binding system that monitors model states and automatically triggers interface updates, providing real-time feedback as users interact with forms. This approach

Spectral is a programmable linting engine and validation tool designed to enforce style guidelines and schema correctness within OpenAPI specifications and JSON configuration files. It functions as a rule-based validator that analyzes structured text files to ensure data consistency and adherence to predefined constraints. The engine utilizes a configuration-driven execution model, allowing users to manage pluggable rule sets and integrate JSON Schema definitions. It supports the creation of custom function-based rules to define complex validation logic beyond static declarations. The projec

ow is a type-safe schema validation library for TypeScript that verifies data integrity at runtime. It functions as a runtime validation framework and type guard utility, ensuring that JavaScript values match expected types and schemas before they are processed. The library synchronizes runtime data checks with static TypeScript type definitions, allowing users to extract type definitions directly from validation predicates. This integration enables type narrowing, where a successful validation result refines the variable type for safer usage in the code. The framework uses a chainable API t

Ajv is a high-performance data validation framework that compiles JSON schemas into optimized, standalone JavaScript functions. By transforming declarative schema definitions into executable code, it eliminates runtime interpretation overhead and provides a secure, efficient way to enforce data integrity across both browser and server environments. The library distinguishes itself through its focus on performance and type safety. It employs advanced compilation techniques, including abstract syntax tree optimization and function caching, to ensure rapid validation. Beyond standard checks, it

This project is a JSON Schema validation library and framework used to verify that data instances conform to declarative definitions. It functions as a validation engine that enforces structural constraints and data types, while also serving as a meta-validator to ensure schema definitions themselves are syntactically correct against official meta-schemas. The library is designed for extensibility, allowing users to define custom validation logic by mapping schema keywords to specialized callable functions. It includes a registry-based reference resolver for managing internal and external URI

Symfony is a full-stack web framework designed for building scalable and maintainable server-side applications. It provides a comprehensive collection of decoupled components that form a foundational architecture, centered on a robust dependency injection container and a configuration-driven routing engine. By organizing code into modular services, the framework ensures that application components remain testable and loosely coupled throughout the development lifecycle. The framework distinguishes itself through an event-driven kernel architecture that allows developers to intercept and modif

Validator.js is a library of pure, stateless functions designed for the validation and sanitization of string data within any JavaScript environment. It provides a modular suite of tools to verify that user-provided information conforms to specific formats, such as emails, URLs, and dates, while simultaneously cleaning untrusted input to mitigate security risks. The library distinguishes itself through a design that avoids platform-specific APIs, ensuring consistent execution across browsers, servers, and edge runtimes. By utilizing a pre-compiled regular expression engine and a pure data tra

async-validator is a JavaScript schema validation library and asynchronous data validation engine. It verifies complex object structures and nested arrays by applying recursive rules and non-blocking, promise-based execution to ensure data integrity. The library functions as both an object constraint validator and a data transformation pipeline. It allows for the sanitization, coercion, and formatting of input values through a sequence of functions that run before and after the primary validation process. The engine covers a range of capabilities including recursive nested validation, the en

Kong is a declarative command line interface framework and parser for Go. It maps flags and positional arguments directly into typed Go structures using struct tags, allowing developers to define terminal interfaces through data models rather than manual parsing logic. The project functions as a configuration mapper that populates Go structures from a combination of command-line arguments, environment variables, and JSON files. It distinguishes itself by providing a dependency injection container to pass external services into command handlers and a plugin architecture for dynamic command reg

Arktype is a TypeScript runtime validation library and schema orchestrator. It synchronizes TypeScript types with runtime data validation, allowing users to define type-safe schemas that ensure unknown data adheres to specific structures during application execution. The project distinguishes itself by using set-theory type analysis to determine intersections and subtype compatibility, alongside JIT-compiled validation functions for optimized performance. It supports advanced type modeling through branded type constraints, recursive alias resolution, and the ability to generate runtime valida

env is a Go library that reads environment variables and populates the fields of a Go struct according to tag directives. It uses reflection to iterate over struct types and tags at runtime, mapping environment variable names to struct fields and applying parsing behavior defined in struct tags. The library supports required field validation, returning errors when marked fields are missing or empty after parsing. It also provides default value fallback from struct tags when environment variables are not set, environment variable expansion that recursively substitutes references within values,

validator.js is a JavaScript string validation and sanitization library. It provides a set of functions to verify that strings match specific patterns—such as emails, URLs, and alphanumeric formats—and a toolkit for cleaning and transforming text input to remove prohibited characters and trim whitespace. The library includes utilities for standardizing email addresses by lowercasing domains and removing sub-addressing markers. It also functions as an HTML entity escaper, replacing special characters with entities to prevent the browser from executing text as code. The project covers capabili

NaughtyAttributes is a collection of custom attributes for the Unity Editor inspector that allows for field validation, the exposure of non-serialized properties, and the addition of custom UI controls. It functions as an extension library to customize how fields are drawn and behave within the inspector interface without requiring the author to write custom editor scripts. The library provides tools for creating interactive elements such as buttons that execute specific methods, as well as specialized input controls like sliders and dropdowns. It enables the display of native properties and

xorm is a relational mapper and object-relational mapping tool for Go. It translates Go structures into SQL queries and maps database rows back into native objects, providing a multi-dialect database driver that supports MySQL, PostgreSQL, SQLite, Oracle, SQL Server, and TiDB. The project features a read-write splitting manager that routes modification requests to a primary database and read requests to replicas. It includes a database schema synchronizer to automatically align table structures and indexes with application data models, as well as a fluent SQL query builder for constructing co

Copier is a Go library that deep copies data between structs, maps, and slices using reflection-based field mapping and struct tag controls. At its core, it automatically transfers values by matching source and destination fields by name, type, and methods, creating fully independent copies of nested data structures to prevent shared references and unintended mutations. The library distinguishes itself through tag-driven copy rules that give developers fine-grained control over the copying process. Struct tags can enforce mandatory field copying, exclude specific fields from transfer, or map

Base UI is a headless component library and unstyled framework providing accessible interface primitives. It decouples behavioral logic and state management from the visual layer, allowing developers to implement complex UI patterns while maintaining total control over the final styling. The library implements WAI-ARIA design patterns to ensure all primitives support standard keyboard navigation and screen reader accessibility. It provides a suite of low-level building blocks that handle the internal mechanics of interface elements without bundling any CSS. The framework covers a broad range

Credo is a static analysis tool and linter for Elixir. It functions as a code quality analyzer that scans source code to identify stylistic inconsistencies, common mistakes, and potential security vulnerabilities. The tool provides a customizable framework for defining and testing specialized rules to enforce project-specific coding standards. It identifies complex code fragments and duplication to highlight opportunities for refactoring and simplification. Its capabilities cover automated code reviews, the enforcement of Elixir coding standards, and real-time developer feedback through edit

This library is a PHP framework for enforcing data integrity and business rules by validating scalar values and complex object structures against predefined constraints. It provides a structured approach to inspecting object graphs and property metadata, ensuring that data conforms to expected requirements before it is processed by an application. The framework distinguishes itself through a metadata-driven mapping system that uses reflection or configuration files to apply rules directly to object properties. It supports contextual rule orchestration, allowing developers to organize constrai

This is a Go library for reading and writing XLSX files, providing a toolkit for spreadsheet generation and data extraction. It functions as an Office Open XML parser and generator, enabling the creation of workbooks with support for styles, formulas, and metadata. The project features a data mapper that uses Go struct tags and reflection to automatically align spreadsheet rows with structured data. It also includes a validation engine for defining input constraints, such as dropdown lists and error alerts, to control user data entry. The library covers a broad range of capabilities, includi

class-validator is a TypeScript class validation library that uses decorators to define constraints and rules for object properties. It functions as a decorator-based schema validator that ensures data integrity and structural correctness through a combination of synchronous checks and promise-based asynchronous rules. The library provides a recursive validation system for checking complex data hierarchies, including nested classes and individual elements within collections. It includes an object property whitelist utility capable of stripping undocumented properties or blocking unknown field

Bun is a type-safe object relational mapper for Go that prioritizes SQL-first query construction and result mapping. It functions as a programmable SQL query builder, a database connection manager, and a tool for mapping database tables to Go structs. The project distinguishes itself through a multi-dialect SQL support system, allowing a single codebase to interact with different database engines via a consistent interface. It includes a built-in database observability tool for query interception, distributed tracing, and logging, as well as a schema migration tool for versioning structural c

yidaRule is a website integration framework and rule repository designed to standardize how external platforms and applications connect to a core engine. It functions as a collection of JSON configuration rule-sets and web integration schemas that map external site behaviors and data patterns to a structured internal environment. The system utilizes a regex-based protocol parser to resolve and process magnet links, extracting file metadata and identifiers for media retrieval. It manages these interactions through a curated repository of rule files that define the specific logic required for d