Cue

CUE is a constraint-based configuration language designed for data validation, schema definition, and code generation. At its core, it unifies types and values into a single concept, enabling compile-time validation that catches structural and value errors before runtime. The language treats data and constraints as the same thing, allowing a single definition to serve as both a schema and concrete configuration data.

CUE distinguishes itself through its constraint-based unification engine, which combines multiple configuration sources into a single coherent result by merging their constraints and automatically resolving conflicts. It supports a value-as-type dualism where types and values are ordered in a lattice, enabling precise subsumption and validation. The language provides built-in mechanisms for struct closure, disjunction-based alternatives, comprehension-based iteration, and dynamic field creation, giving users fine-grained control over data modeling without requiring explicit validation code.

The tool translates data between CUE, JSON, YAML, TOML, Go, Protobuf, and OpenAPI formats without losing meaning, and generates Go code, Protobuf definitions, and OpenAPI specs from CUE schemas. It offers a command-line interface for validating and processing configuration files, a Go API for programmatic integration, and script-driven data automation for orchestrating data processing workflows. CUE can be installed via Homebrew, binary download, Docker, Arch Linux packages, or built from source using Go.

Features

Constraint-Based Configuration Languages - Creates and validates large-scale configuration files using a constraint-based language that unifies types and values.
Constraint-Based Configuration Languages - Defines and validates configuration data using a constraint-based language that unifies types and values.
Data Format Translators - Reads and writes information in JSON, YAML, and Protobuf, translating between them without losing meaning.
Numeric Range Constraints - Defines bounds like >=0 or <10 to restrict numeric values to ranges, acting as infinite disjunctions.
Data Schema Definitions - Defines reusable data schemas using a declarative language for structuring and constraining configuration data.
Data Source Unification - Combines data from different sources by merging constraints into a single consistent result.
Typed Configuration Schemas - Defines reusable typed schemas that describe the shape and constraints of configuration data.
Configuration Unifiers - Combines separate configuration sources into a single coherent result with automatic conflict detection.
Struct Field Declarations - Creates structured maps from labels to values with nested fields and pattern constraints.
Value Embeddings - Embeds expressions inside structs to unify their results, bypassing closed-struct restrictions.
Reference Cycle Resolution - Detects and resolves reference cycles in configuration by treating self-referencing fields as top.
Disjunctive Constraint Operators - Declares values that can be one of several alternatives using the | operator with sum type support.
Closed Definition Schemas - Declares definitions with # prefix that are automatically closed, enforcing fixed field sets across all usages.
Project Constraint Validation - Checks data against user-defined constraints and reports violations to ensure correctness.
Configuration File Validators - Checks and validates existing JSON, YAML, and native configuration files against CUE constraints.
Compile-Time Data Constraint Definers - Defines precise value constraints and schemas validated at compile time.
Configuration Validators - Validates JSON, YAML, and CUE files against user-defined constraints from the terminal.
Constraint-Based YAML Validators - Reads and validates YAML files with user-defined constraints, replacing anchors with reliable references.
Reusable Typed Schemas - Creates reusable, typed schemas that describe the shape and constraints of configuration data.
Closed Definitions - Declares definitions with a # prefix that are closed by default and enforce structure when referenced.
Constraint-Based Unifiers - Combines multiple configuration sources into a single coherent result by merging constraints automatically.
Constraint Unification Mergers - Combines multiple configuration sources by merging constraints into a single result.
Multi-Source Configuration Loaders - Combines settings from JSON, YAML, TOML, and other formats into a single coherent configuration.
Validated Data Exports - Produces validated, concrete data in JSON or YAML for consumption by external tools.
Comprehension Iteration Constructs - Provides comprehension-based iteration with for, if, and let constructs for generating list elements and struct fields.
Dynamic Field Label Expressions - Computes field labels at evaluation time using parenthesized expressions for data-driven struct keys.
Constraint Unification Operators - Implements the & operator to unify list elements into a single constraint, returning top for empty lists.
Struct Closure Builtins - Provides language-level builtins that convert open structs to closed ones, preventing undeclared fields.
Struct Composition - Embeds one struct's fields into another, bypassing closed-struct restrictions for flexible composition.
Struct Field Restriction Mechanisms - Marks structs as closed to prevent addition of undeclared fields, catching typos and extra properties.
Type-Value Lattice Definitions - Defines data and constraints using a lattice-based value system where types and values are ordered for precise validation.
Value Lattices - Organizes values in a partial order with unique greatest lower bounds for type-value unification.
Disjunct Default Selectors - Marks disjuncts with an asterisk to select preferred values when resolving expressions to concrete output.
Value References - Derives one configuration value from another using references, reducing duplication and keeping configurations consistent.
Data Encoders and Decoders - Converts data between CUE and various formats such as JSON, YAML, and Protobuf for interoperability.
Multi-Format - Converts between CUE and multiple data formats using built-in encodings for system interoperability.
Data Validation Schemas - Defines and enforces constraints on data structures, ensuring values conform to expected types and formats.
Schema Default Values - Assigns fallback values to disjuncts so they are selected when expressions must resolve to a single concrete value.
Versioned Configuration Modules - Organizes configuration logic into shareable, versioned modules that can be imported and reused across projects.
Constraint-Based JSON Validators - Validates JSON data against user-defined constraints to enforce structure and values.
Conditional and Multi-Schema Validators - Ships built-in validators like matchN and matchIf for conditional and multi-schema constraint checking.
Schema-Driven Code Generators - Generates Go code, Protobuf definitions, and OpenAPI specs from CUE schemas.
Default Value Applications - Applies policies and defaults to eliminate repeated values, keeping configuration concise and maintainable.
Constraint-Value Dualisms - Unifies types and values so a single definition serves as both schema and data.
Typed Constraint Definitions - Defines constraints where types and values are the same concept, making data definitions clear and concise.
Value Unifications - Combines two values into their greatest lower bound, producing a more specific value.
Validation API Integrations - Integrates validation and schema capabilities directly into Go applications via its API.
Infinite Range Bounds - Defines infinite sets of concrete values using comparison operators for numeric range constraints.
Multi-Format Data Readers - Reads and validates data from JSON, YAML, and other formats into a unified configuration.
Structured Data Format Converters - Translates data between CUE, JSON, YAML, TOML, Go, Protobuf, and OpenAPI formats.
Expression-Based Data Validations - Uses a rich set of expressions to construct, validate, and process data within configurations.
Structured Data Importers - Imports structured data from JSON and YAML files directly into CUE for validation.
Schema Validators - Validates data files against schemas directly in the terminal for script integration.
Built-in Validation Functions - Uses functions like matchN and matchIf to check that a value satisfies a conditional or multi-schema constraint.
Constraint-Based Data Navigators - Navigates nested data to extract, reshape, or combine values using constraint-based paths.
Multi-Format Encoders - Translates data between CUE, JSON, YAML, TOML, Go, Protobuf, and OpenAPI.
OpenAPI Argument Validators - Uses OpenAPI data schemas directly to validate JSON or YAML data.
Protobuf Contract Validators - Validates data values beyond Protocol Buffer schemas to extend their validation capabilities.
Value Validators - Extends Protocol Buffer schemas to validate data values, not just structure.
Field-Level Metadata Annotations - Attaches metadata like @go(Field) or @xml(attr) to fields for mapping to external representations.
Command-Line Tools - Ships command-line tools to validate, format, and process CUE files and configurations.
Policy-Based Validations - Validates data against defined policies by treating types and values as a unified concept.
Configuration Module Dependencies - Declares and resolves external module dependencies for sharing definitions across projects.
Multi-Format Data Exports - Converts validated configurations and schemas into standard data formats for use in other systems.
Multi-Format Data Processors - Reads and writes data in JSON, YAML, Go, and other formats for cross-tool exchange.
Data Format Importers - Converts external data formats like JSON into internal representations for processing.
Webhook Configuration Removal - Applies policies to template values and defaults, automatically removing redundant information from configurations.
Go Code Generators - Produces Go types and code that mirror CUE definitions for type-safe data handling.
List Length Builtins - Returns the number of elements in a list or the minimum length for open lists using the len builtin.
Euclidean Division Utilities - Computes truncated and Euclidean quotients and remainders using quo, rem, div, and mod builtins.
Data Processing Expressions - Uses a rich set of expressions to construct, validate, and transform data within configurations.
Go-to-Schema Translators - Uses its Go API to validate, constrain, and convert data, including translating Go types into CUE schemas.
Schema Inferences from Sample Data - Infers type definitions from sample JSON or YAML data to serve as validation templates.
Data Sync Conflict Resolution - Resolves conflicts when combining multiple data sources or schemas into a single result.
Configuration Package Imports - Splits configurations into separate packages for modular and scalable setups.
JSON Schema Validation - Reads JSON Schema definitions as CUE constraints and validates data against them.
JSON Schema Converters - Validates data against JSON Schema constraints and converts between JSON Schema and native formats.
Configuration Defaults - Applies policies and templates to automatically fill in defaults and eliminate redundant values from configurations.
OpenAPI Specification Validators - Validates data directly against OpenAPI schemas to simplify working with OpenAPI definitions.
Builtin Error Generators - Provides the error builtin to generate bottom values with custom error messages during validation.
Configuration Languages - Validates and generates configuration data using a constraint-based language.

colinhacks/zod

43,036View on GitHub

Zod is a TypeScript-first schema declaration and validation library designed to ensure end-to-end data integrity. It functions as a runtime type guard, allowing developers to define complex data structures through a declarative, chainable syntax. By using these schema definitions, the library automatically derives static TypeScript types, eliminating the need for manual type duplication and ensuring that runtime data matches expected application contracts. The library distinguishes itself through functional schema composition, which enables the creation of hierarchical structures by nesting a

gcanti/io-ts

6,813View on GitHub

io-ts is a TypeScript runtime validation library that provides a composable codec system for decoding and encoding data at the boundaries of an application. It defines data schemas using structural types, where the shape of data determines its validity rather than nominal names, and produces runtime type guards from those definitions for efficient validation checks. The library is built around bidirectional codec mappings that combine decoding, encoding, and type checking into single reusable units. It supports a composable decoder pipeline where small validation steps can be chained together

pyeve/eve

6,738View on GitHub

Eve is a REST API framework that maps database collections to web resources through declarative configuration files. It functions as a database-to-API mapper, automatically exposing data as RESTful endpoints with built-in support for CRUD operations and schema-based request validation. The project distinguishes itself through a HATEOAS API engine that generates hypermedia links and resource schemas for dynamic client discovery. It also includes an automated Swagger documentation generator that produces interactive specifications for client SDK generation and testing. The framework provides a

zxlie/FeHelper

5,618View on GitHub

FeHelper is a web browser extension toolbox and frontend development toolkit integrated into Chrome, Firefox, and Edge. It serves as a data transformation utility, a web page debugging tool, and an AI-powered coding assistant. The project distinguishes itself by integrating local models and OpenAI-compatible APIs to write, refactor, and repair code directly within the browser. It also provides capabilities for generating TypeScript schemas and Zod definitions from data samples using AI. The toolkit covers a broad range of developer utilities, including network debugging for HTTP and WebSocke

cue-langcue

Features