Open-source alternatives to Validator

Yup is a JavaScript schema validation library used to define data shapes and validate runtime values. It functions as an object schema validator and a data coercion engine, allowing developers to transform raw input values into desired types before performing validation checks. The library is distinguished by its support for dynamic schema validation, where rules can be adjusted at runtime based on sibling field values or external context. It also enables recursive data structuring for polymorphic fields and provides a system for extracting static TypeScript interfaces from runtime schema def

react-final-form is a React form state management library that provides a framework for declarative form validation and the orchestration of dynamic input fields. It utilizes a subscription-based state manager to trigger interface updates only for the specific fields that change during user input, which optimizes rendering by limiting unnecessary component re-renders. The library functions as a dynamic input field orchestrator, allowing users to add, remove, or reorder lists of form fields. It manages complex form state through a system that supports conditional field rendering and real-time

Vee-validate is a form validation library and state management tool for Vue applications. It enables the validation of user inputs through declarative rules and tracks form metadata, including submission status and dirty states. The library functions as a wrapper for integrating external schema validation libraries to enforce consistent data shapes. It also serves as an internationalized framework for displaying translated error messages and localized feedback. The project covers broad capability areas including form state management, the handling of complex nested data structures, and the s

protobuf.js is a JavaScript and TypeScript library for encoding and decoding structured data using the Protocol Buffers binary format. It functions as a dynamic parser that can load and process schemas at runtime, a JSON transcoder for converting messages to human-readable formats, and a framework for building transport-agnostic remote procedure call clients. The project distinguishes itself by offering both dynamic message handling and a static code generator that produces TypeScript declarations and JavaScript modules to reduce runtime overhead. It also provides a reflection API for definin

This is a Go struct validation library used to maintain data integrity by enforcing constraints on fields, slices, and maps. It functions as a schema validation tool and data integrity validator, ensuring that complex nested structures adhere to predefined rules. The library utilizes struct tags to configure validation logic at runtime and supports a custom function registry for extending validation rules. It is distinguished by its ability to perform cross-field dependency evaluation, allowing the comparison of values between different fields within the same data structure to ensure logical

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

Templ is a type-safe HTML templating engine and UI framework for Go. It provides a system for building reusable HTML components that compile into Go code for server-side rendering, ensuring type safety and compile-time validation of data and logic. The project features a dedicated language server that provides autocomplete and syntax validation for template files within supported code editors. It employs compile-time code generation to transform a custom template language into Go source code, enabling the creation of modular HTML fragments and logic blocks. The framework includes automated s

Typia is a compile-time code generator that transforms TypeScript type annotations into runtime validation, serialization, and schema functions without requiring decorators or separate schema files. It generates optimized validation and serialization code during TypeScript compilation, producing dedicated functions for each type that eliminate runtime schema objects for faster execution. The project extends this core capability into several integrated areas. It generates fully typed client SDKs from NestJS controller source code, keeping server and client types synchronized automatically. It

Moshi is a JSON serialization library and parser for Kotlin and Java. It functions as a reflectionless JSON encoder that converts typed objects to JSON strings and parses JSON data back into language objects. The library distinguishes itself through compile-time adapter generation, which removes the performance overhead associated with runtime reflection. It also provides a polymorphic JSON mapper that uses type identifiers to resolve and instantiate specific subclasses of a common base type. The framework supports custom adapter definitions for specialized type conversion, including nullabi

Ent is a statically typed entity framework for Go that models database structures as a graph of nodes and edges. It functions as a code generation engine that transforms schema definitions into type-safe database clients, query builders, and migration scripts. By representing data as interconnected entities, the framework enables intuitive traversal of complex relationships and ensures that database interactions remain consistent with the application model at compile time. The framework distinguishes itself through its graph-based approach to data modeling and its reliance on compile-time cod

This project is a framework for the efficient serialization and deserialization of data structures. It provides a unified, macro-based interface that automates the conversion of complex internal objects into standardized formats and reconstructs them from raw input streams or buffers. By leveraging compile-time code generation, the library minimizes manual implementation overhead while ensuring consistent logic across diverse data types. The framework distinguishes itself through a format-agnostic data model and a visitor-based parsing architecture that decouples data structures from specific

ButterKnife is an Android view binding library and Java annotation processor that automates the linking of UI elements and resources to class fields and methods. It functions as a system for managing view references and event listeners to reduce repetitive setup code in Android applications. The library uses compile-time code generation to replace manual view lookups and type casting with generated helper classes, ensuring a reflection-free runtime. It differentiates itself by providing mechanisms for binding interaction events directly to methods, eliminating the need for anonymous inner cla

u2020 is an example Android application that demonstrates how to wire together application components using compile-time dependency injection, annotation-driven view binding, and a slide-out debug drawer. The project serves as a real-world showcase for integrating Dagger for dependency injection and Butter Knife for view binding, both of which generate code at compile time rather than relying on runtime reflection. The application features an in-memory mock server that simulates backend responses using static data, enabling development and testing without a live network. A debug drawer overla

Babel Plugin Macros is a framework for building compile-time code transformations that modify JavaScript and TypeScript source files during the build process. It enables developers to automate repetitive code generation tasks and execute custom logic without the overhead of writing and maintaining full-scale, complex compiler plugins. The project distinguishes itself by using import-based discovery to trigger transformation modules, allowing developers to invoke specific logic directly through standard module imports. It provides a structured environment for managing macro execution sequences

The Swift OpenAPI Generator is a build-time tool that produces type-safe Swift client and server code directly from OpenAPI specification documents. By integrating with build systems through native plugins, it automates the creation of strongly-typed interfaces and protocol stubs that map network operations to native methods, ensuring that application code remains strictly consistent with defined data schemas. The project distinguishes itself through a protocol-oriented architecture that decouples business logic from specific transport implementations. It utilizes a pluggable transport layer

This library is a high-performance JSON processing tool for Java designed to handle data serialization and deserialization with minimal resource consumption. It provides a framework for transforming complex object graphs into JSON strings and mapping raw input directly to typed class properties. The library distinguishes itself by utilizing compile-time code generation and reflection-free mapping to eliminate expensive runtime overhead. By employing iterator-based stream parsing and zero-allocation buffer management, it processes large or deeply nested data structures while reducing garbage c

This library is a data processing framework for the JVM that provides a type-safe environment for manipulating structured tabular data. It functions as a comprehensive toolset for performing complex data transformations, aggregations, and statistical analysis, while leveraging compile-time schema validation to ensure structural integrity across data pipelines. The project distinguishes itself through its deep integration with interactive notebook environments and its use of compile-time code generation. By automatically deriving and enforcing schemas from raw inputs, it generates type-safe ac

Apollo Kotlin is a strongly-typed GraphQL client and code generation library designed for Kotlin and JVM applications. It functions as a comprehensive development tool that transforms GraphQL schema definitions and query documents into type-safe models during the build process, ensuring that data access errors are identified at compile time rather than at runtime. The project distinguishes itself through its multiplatform runtime abstraction, which allows developers to share data fetching and caching logic across Android, iOS, and desktop environments. It provides a normalized local caching s

Typesafe-i18n is a localization framework for TypeScript applications that provides compile-time validation for translation keys and parameters. By generating type definitions directly from translation files, it ensures that all localized content is strictly typed, preventing runtime errors caused by missing or mismatched data. The project distinguishes itself through its automated workflow, which uses command-line utilities to generate boilerplate code and wrapper functions. It supports complex linguistic requirements, including pluralization, date and number formatting, and conditional mess

apollo-ios is a GraphQL client library for iOS and Apple platforms that enables type-safe network communication. It transforms GraphQL operations into generated Swift models, ensuring that network responses are validated at compile time to eliminate manual mapping. The library features a normalized cache manager that stores entities in a flat structure to maintain data consistency across different application views. It also optimizes network performance using hash-based persisted queries to reduce payload sizes and supports real-time data streaming via WebSockets or HTTP subscriptions. The p

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

Relay is a GraphQL client framework and state manager used for building data-driven applications. It functions as a declarative data fetching layer and a GraphQL compiler that transforms declarations into optimized runtime code with automatic type generation. The framework distinguishes itself through a build-time compilation process that generates optimized queries and a data masking system that prevents components from accessing undeclared data. It employs a normalized client-side cache to maintain consistency across entities and an optimistic update mechanism to provide immediate interface

greenDAO is an object-relational mapping library for Android that maps Java objects to SQLite databases. It provides infrastructure for high-performance data persistence by translating data objects into database records and vice versa. The library implements a type-safe query builder for retrieving records across multiple entities using joins and relationship chaining. It also includes a security layer that provides full-disk encryption for the SQLite database to prevent unauthorized access to stored information. The system utilizes compile-time code generation to create mapping classes, avo

CXX is a code generator that produces a safe, zero-overhead FFI bridge between Rust and C++. It lets functions and data types from either language be used directly in the other, with static type safety enforced at compile time and no copying, serialization, or runtime checks across the boundary. The bridge supports the full range of cross-language interactions: Rust can call C++ functions and use C++ types, and C++ can call Rust functions and use Rust types. Standard library types like strings, vectors, and smart pointers are mapped automatically between the two languages, while opaque types

thiserror is a Rust error handling library and procedural macro designed to define custom error types. It functions as a trait implementation automator that generates the necessary code for standard library error traits at compile time. The library focuses on eliminating boilerplate by using derive macros to automatically implement display and source methods. It allows for the creation of custom error structs and enums that can map low-level errors to high-level variants while preserving the original cause and backtrace information. Its capabilities cover custom error formatting through temp

Kotlin-inject is a dependency injection framework for Kotlin that utilizes compile-time code generation to construct type-safe object graphs. By processing declarative annotations during the build process, the library eliminates the need for runtime reflection, ensuring that dependency resolution and validation occur before the application executes. The framework distinguishes itself through its native support for Kotlin Multiplatform, enabling consistent dependency management across shared and platform-specific codebases. It provides specialized mechanisms for assisted injection, allowing de