Projects sharing features with Bufbuild Buf

Prost is a Protocol Buffers implementation for Rust that functions as a binary serialization framework and code generator. It translates schema definitions into idiomatic Rust structs and enums, providing the logic necessary to encode and decode structured data into the Protocol Buffers binary format. The project distinguishes itself through a no-std implementation, allowing it to operate in embedded or kernel environments that lack a standard library. It also serves as a schema introspector by emitting file descriptor sets, which enables the programmatic analysis of original schema definitio

Kratos is a toolkit for building cloud-native microservices in Go. It provides a comprehensive suite of framework primitives, including a dedicated toolset for API-first development using Protobuf to generate server and client code for gRPC and HTTP. The project is distinguished by its pluggable service infrastructure, which allows for the swapping of configuration stores, service registries, and data encoding formats. It utilizes a composable middleware pipeline to inject cross-cutting concerns such as authentication, request validation, and circuit breaking into the service flow. The frame

Atlas is a SQL database schema management tool and database infrastructure as code framework. It provides a declarative database migration engine that computes the difference between a desired schema state and the current database state to automatically generate the necessary SQL for transitions. The project distinguishes itself through a comprehensive suite of analysis and visualization tools, including a database schema linter that detects destructive changes and data loss risks. It also features a SQL schema visualization tool capable of generating entity-relationship diagrams from extract

sqlc is a code generation tool that compiles raw SQL queries into type-safe application code. By analyzing SQL statements against database schema definitions during the build process, it eliminates the need for manual data mapping and prevents runtime type errors. The project functions as a schema-aware generator that translates database column types into native language primitives. It distinguishes itself through a modular, plugin-based architecture that allows for the extension of the generation pipeline to support diverse programming languages and custom frameworks beyond its default capab

This project is an IntelliJ IDE plugin that provides an integrated development environment for Rust. It serves as a build system orchestrator and debugger interface, offering comprehensive language analysis, syntax highlighting, and intelligent code editing assistance. The plugin integrates with a language server to provide real-time type inference and code navigation. It includes a dedicated static analysis tool for detecting code duplicates, analyzing memory leaks, and measuring test coverage. The toolset covers toolchain management and Cargo integration for dependency and manifest handlin

AKHQ is a web-based management interface for Apache Kafka, providing a centralized platform for administering clusters, topics, and consumer groups. It serves as a comprehensive monitoring and administration tool that includes a Kafka Connect manager and a ksqlDB administration interface. The platform distinguishes itself through extensive schema registry integration, allowing users to browse and decode Avro, Protobuf, and JSON messages using Confluent, Tibco, or AWS Glue registries. It also features a granular security model with role-based access control, sensitive data masking, and support

JSHint is a JavaScript static analysis tool and linter designed to detect errors and enforce coding standards. It functions as a syntax validator that scans source code to identify potential logic problems and programming mistakes before the code is executed. The tool provides a command line interface for analyzing files and directories. It supports the export of analysis results into standardized formats such as Checkstyle for integration with external build tools. Analysis is managed through a system of linting rule management and environment global configuration. This includes the ability

The YAML Language Server is a backend service that provides intelligent editing support for YAML files by implementing the Language Server Protocol. It functions as a validation and analysis engine, enabling code editors to offer real-time diagnostics, structural feedback, and automated assistance for configuration-heavy development workflows. The project distinguishes itself through its schema-driven approach to data integrity, utilizing a JSON Schema validation engine to verify document structure against formal definitions. It supports complex configuration management by allowing developers

Luban is a game configuration toolchain designed to convert spreadsheet-based data into optimized binary formats and type-safe source code for multiple languages. It functions as a comprehensive suite for configuration validation, data serialization pipelines, and code generation to ensure data consistency across different platforms. The system features a multi-language code generator that produces strongly-typed data classes from schemas, eliminating the need for reflection. It includes a localization manager for exporting translated text and assets with locale-specific patching, and a seria

This project is a command-line schema-to-code converter designed to transform diverse data specifications into type-safe Python data structures. It functions as a generator for Pydantic models, dataclasses, and typed dictionaries, enabling developers to maintain synchronization between evolving data contracts and application code. By parsing formats such as JSON Schema, OpenAPI, AsyncAPI, Protobuf, and Avro, the tool automates the creation of native classes that reflect the constraints and metadata defined in the source specifications. The generator distinguishes itself through a highly confi

sqlboiler is a database-first ORM generator for Go that analyzes an existing database schema to produce strongly typed structures and query helpers. It functions as a schema-driven code generator, transforming database tables and relationships into executable Go source code. The project distinguishes itself through a type-safe query builder that uses chainable modifiers to construct SQL statements, eliminating the need for raw string concatenation. It utilizes customizable text templates to generate source code, allowing for the aliasing of schema entities and the creation of custom templates

SchemaStore is a centralized JSON schema registry and configuration validation service. It serves as a searchable catalog of standardized JSON definitions used to verify that configuration files adhere to predefined structural rules and data types. The project functions as an autocomplete provider, suggesting available keys and valid values for configuration files during the editing process. It employs a remote directory of schemas indexed by file path and pattern to provide a single source of truth for validation and autocompletion in text editors. The system covers automated configuration

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

gqlgen is a schema-first Go library designed to build type-safe GraphQL servers. It functions as a code generation engine that transforms declarative GraphQL schema definitions into strongly-typed Go source code, ensuring strict alignment between the API contract and the underlying implementation. The framework distinguishes itself through its deep integration with the Go type system and its highly extensible build pipeline. By using schema-first development, it automates the creation of server boilerplate and resolver stubs, allowing developers to map schema fields directly to Go structs and

Quicktype is a multi-language serialization tool and type generator. It converts JSON samples, JSON Schema definitions, and GraphQL schemas into strongly typed data structures and serialization logic across multiple programming languages. The system automates the data serialization workflow by generating boilerplate code to parse and serialize data. It transforms structured input definitions into executable code, providing the necessary encoders and decoders to move data between raw formats and typed objects.

openapi-ts is a tool and orchestrator used to convert OpenAPI specifications into type-safe TypeScript SDKs and HTTP client implementations. It automatically generates typed interfaces and request functions from API definitions to ensure consistency between the server and the client. The project employs a transport-agnostic client interface, decoupling high-level API calls from the underlying network library. It uses a plugin-based generation pipeline and a custom plugin architecture to allow for the customization of output types and validation schemas. The system provides capabilities for n

Quicktype is a multi-language model generation engine that converts JSON and GraphQL schemas into type-safe models and serialization code. It functions as a JSON to type generator and a GraphQL type generator, producing strongly typed classes and interfaces across a wide array of target programming languages. The system derives formal schemas from sample data and transforms these definitions into native language objects. This enables the synchronization of shared data models across diverse tech stacks and the development of type-safe interfaces for consuming external APIs. The engine utilize

jOOQ is a type-safe SQL query builder for Java that generates code from live database schemas, enabling compile-time validation of SQL syntax and data types. Its core identity is built around a fluent DSL that mirrors SQL structure, a code generator that maps tables, views, and routines to Java objects, and a multi-dialect engine that translates the same DSL into vendor-specific SQL for over 30 databases. The project also includes a SQL parser and transformer for refactoring or dialect conversion, reactive stream integration for non-blocking query execution, and a JDBC proxy diagnostics tool f

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

jsoncrack.com is a JSON data visualization tool and interactive graph viewer that transforms JSON and other structured data formats into visual tree diagrams. It functions as a data syntax validator and a structured data converter for transforming information between JSON, YAML, XML, and CSV formats. The project includes a JSON schema generator that produces schema definitions and language-specific type definitions based on provided structured data. These capabilities automate type safety and ensure data integrity through schema generation. The tool provides broader capabilities for structur

rinf is a cross-platform native bridge and integration layer used to connect business logic written in Rust to application frontends. It functions as a cross-language message broker and binary serialization framework that enables the exchange of structured data between a Rust backend and user interfaces across mobile, desktop, and web targets. The project utilizes a schema-driven code generator to produce language-specific message classes from shared definitions. This ensures type-safe message passing and consistency across different programming environments, preventing data mismatches during

Glad is a cross-platform graphics API loader generator that produces source code for loading function pointers based on official specifications. It functions as a multi-language tool designed to ensure consistent communication between applications and graphics drivers across different operating systems and hardware. The tool utilizes a plugin-based architecture to generate loading code for multiple programming languages. It employs specification-driven code generation, parsing official XML or JSON files to ensure the correctness of function signatures and mapping optional API extensions to sp

Amplication is a low-code API platform and backend service generator designed to accelerate the development of business domain services. It automates the creation of APIs and data models through schema-driven code generation, transforming structured definitions into executable backend source code. The platform functions as a developer portal orchestrator that establishes standardized workflows and golden paths for software delivery. It enforces organizational coding standards and best practices by applying live templates and predefined blueprints across all generated services. The system inc

Nanopb is a lightweight C implementation of Protocol Buffers designed for resource-constrained systems and microcontrollers. It functions as both an embedded serialization library for encoding and decoding structured data and a code generator that transforms definition files into compact C source and header files. The project is distinguished by its focus on static memory allocation, using fixed maximum sizes for strings and arrays to avoid dynamic memory allocation and heap fragmentation. It employs a callback-based streaming mechanism to process messages or fields that exceed available phys

The AWS SDK for Go is a software development kit and cloud infrastructure library used to programmatically interact with AWS cloud services. It provides a programmatic interface for authenticating requests, executing operations against regional endpoints, and automating the creation and management of cloud resources. The toolkit utilizes model-driven code generation to create service clients and employs a session-based configuration system to share credentials and global settings across those clients. It implements signature-based request authentication to verify identity and integrity throug

Orval is an OpenAPI-to-TypeScript code generator that produces fully typed API clients, data-fetching hooks, mock data, validation schemas, and server handlers from OpenAPI or Swagger specifications. It reads any YAML or JSON API specification and generates TypeScript interfaces, HTTP request functions, and framework-specific integration code that ensures compile-time correctness for all API calls. The project distinguishes itself by generating production-ready data-fetching hooks for React Query, Vue Query, Svelte Query, Solid Query, Angular, and SWR, complete with automatic cache invalidati

xo is a tool for generating type-safe Go models and query execution code from SQL database schemas and queries. It functions as a multi-dialect SQL tool supporting PostgreSQL, MySQL, SQLite, Oracle, and Microsoft SQL Server to produce idiomatic source code. The project uses a template-based generation system, allowing the structure and logic of the generated database source code to be defined through customizable text templates. It also includes a database schema visualizer that analyzes table relationships and definitions to create visual diagrams and structured documentation. The tool's ca