Open-source alternatives to Swagger Codegen

Fern is a toolset for managing API specifications, generating type-safe client libraries, and producing hosted developer documentation. It provides a utility for validating, transforming, and exporting API definitions into standardized OpenAPI formats, serving as a system to maintain a consistent source of truth for API designs. The project differentiates itself through an automated SDK distribution pipeline that publishes generated libraries to package managers such as npm, PyPI, Maven, and NuGet. It also includes an AI-powered search assistant trained on API and SDK specifications to answer

NSwag is a toolchain for the .NET ecosystem designed to automate the generation of API documentation, server controllers, and typed client proxies from OpenAPI contracts. It functions as a contract-first API tool that enables the creation of server-side boilerplate and client libraries based on predefined specifications. The suite distinguishes itself through its ability to extract OpenAPI specifications from existing ASP.NET Core code via reflection and its capacity to generate type-safe TypeScript client proxies. It also provides an interactive documentation server that hosts and renders th

AutoRest is a multi-language SDK generator and OpenAPI code generator designed to produce consistent software development kits from a single API definition. It functions as a REST API client generator that transforms Swagger and OpenAPI specification files into functional, typed HTTP client libraries. The tool automates the SDK development workflow by converting design documents into source code, ensuring that the resulting implementations match the defined API contract across different programming languages. The system employs specification-driven development using an intermediate represent

oapi-codegen is a suite of generators that converts OpenAPI 3 specifications into type-safe Go client libraries, server boilerplate, and data models. It provides tools for producing production-ready HTTP clients and server-side interfaces to ensure that Go implementations remain compliant with defined API contracts. The tool supports server generation across various web frameworks and allows for extensive customization via template overrides, specification overlays, and custom type definition mappings. It handles complex API requirements through external reference resolution to organize code

Goa is a design-first Go framework that generates server and client code, documentation, and request validation from a single declarative domain-specific language (DSL). At its core, it provides a Go DSL for defining API endpoints, data types, and error models, which compiles into fully functional HTTP and gRPC server stubs, client packages, and OpenAPI specifications. The framework distinguishes itself through its plugin-extensible code generation pipeline, allowing custom code generation steps, middleware, or transport layers to be added via plugins. It supports multiple transport protocols

Flasgger is a documentation framework for Flask applications that generates OpenAPI specifications and an integrated Swagger UI. It functions as a documentation generator and specification parser that extracts API schemas from route definitions, function docstrings, and external specification files. The tool allows API definitions to be maintained either within the source code using YAML blocks in docstrings or decoupled into standalone YAML files. It provides a browser-based interactive console for testing and exploring API endpoints directly from the web application. Beyond documentation,

This project is a centralized API specification registry and governance framework. It serves as a source of truth for structured API schemas, gRPC definitions, and data models used to maintain consistency across a large ecosystem of services. The system functions as a multi-language client generator, transforming standardized interface definitions into executable source code and language-specific libraries. This process ensures that client libraries and technical documentation remain synchronized by deriving them directly from the original interface definitions. The project also covers the m

apidoc is a source-code API documentation generator that parses specialized annotations within comments to automatically create a searchable API documentation website. It functions as an annotation-based API parser and a static documentation site generator, extracting definitions directly from the codebase to maintain a synchronized reference. The tool is designed as a multi-language parser, using configurable regular expressions to extract metadata from various programming languages. It can also serve as a JSON API definition exporter, converting source-code comments into raw JSON files for

Kiota is a multi-language SDK generator and REST API client orchestrator that transforms OpenAPI descriptions into strongly typed client libraries. It provides a framework for managing API specifications and generating typed interfaces to eliminate manual boilerplate development. The project utilizes a template-driven source emission system to map API specifications to native language types. It ensures consistency across environments using lock-file version syncing and organizes API endpoints into a nested object structure based on the hierarchical mapping of URI paths. The toolset includes

This project is an automated documentation generator that synchronizes API reference materials with actual code behavior. By capturing live HTTP request and response data during the execution of existing test suites, it ensures that documentation remains accurate and consistent with the underlying application. The tool distinguishes itself by integrating directly into the test runner lifecycle, allowing developers to define API specifications and metadata within their test blocks. This approach enables a test-driven documentation workflow where API behavior is recorded and mapped to structure

ReDoc is an OpenAPI documentation generator that transforms OpenAPI and Swagger specifications into interactive, three-panel API reference websites. It provides a system for generating these references as standalone static HTML files or as embedded UI components for integration into existing websites and developer portals. The tool organizes API specifications into a responsive layout featuring a navigation sidebar, detailed endpoint descriptions, and language-specific code samples. It supports the visualization of complex data models by mapping schema definitions to human-readable tables and

NSwag is an OpenAPI toolchain for .NET that provides a suite of generators for converting OpenAPI specifications and JSON schemas into clients, server stubs, and structured documentation. It enables the creation of type-safe client libraries and data transfer objects, as well as the generation of OpenAPI specifications by analyzing .NET controllers. The project supports contract-first API development by generating server controller stubs from specifications and offers dedicated TypeScript API integration to ensure type safety in frontend applications. It also provides tools for hosting intera

Dokka is an extensible documentation engine designed to generate structured API reference materials for Kotlin projects. By parsing source code and comments, it functions as a static site generator that transforms codebases into readable documentation. It integrates directly into development workflows as a build system plugin, allowing for the automated creation of reference materials during the standard compilation process. The project distinguishes itself through a modular, plugin-driven processing pipeline that allows developers to modify the generation workflow, customize output formats,

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

Hertz is a high-performance Go HTTP framework designed for building scalable microservices, RESTful APIs, and AI applications. It functions as a high-performance web server and a communication framework for microservices, utilizing non-blocking I/O and zero-copy memory management to handle high-concurrency traffic. The project distinguishes itself through a microservices communication toolkit that supports high-efficiency remote procedure calls via gRPC and Thrift protocols. It implements an asynchronous middleware engine based on an onion model, allowing for a pluggable request-response pipe

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

api-blueprint is a markdown-based API design language and specification standard used to define the structure, behavior, and data schemas of HTTP web services. It provides a formal method for mapping HTTP methods to resources and defining payload validation rules through a machine-readable syntax. The project functions as a blueprint for creating interactive technical documentation and functional mock servers. These tools transform design specifications into human-readable guides and simulated backend environments to enable integration testing before implementation. The language covers API m

RAML is a declarative YAML-based specification language used for modeling RESTful interfaces and data structures. It functions as a contract-first API framework and modeling standard, establishing a formal agreement for service communication and a single source of truth before implementation begins. The specification enables the automation of functional mock servers and the generation of language-specific client SDKs directly from the definition files. It supports a modular approach to API design through the use of external libraries, overlays for extending contracts, and reusable traits and

This project is a REST API framework for NestJS designed to automate the creation of boilerplate-free CRUD endpoints and resource management. It functions as an automated CRUD generator that produces controllers and services for standard database operations, accelerating the development of RESTful APIs. The toolkit includes a REST query parser that translates complex URL parameters into structured database filters, pagination, and sorting rules. It also operates as an API response serializer to control the exposure of entity fields and manage nested relations within JSON responses. For extend

This project is a foundational server template built with NestJS designed for creating REST APIs and enterprise backend environments. It provides a pre-configured structure that integrates database connectivity, authentication, and common API services. The boilerplate includes a security system utilizing JSON Web Tokens and role-based access control to manage user sessions and restrict resource access. It supports internationalization for serving content in multiple languages and provides a containerized environment using Docker for consistent deployment. The framework covers a broad range o

This project is a code scaffolding tool and database-to-code mapper for Laravel. It functions as a CRUD generator and REST API generator that automates the creation of models, controllers, and administrative interfaces based on database schemas. The tool is distinguished by its template-driven approach, using customizable stub files that allow developers to override default blueprints to enforce specific architectural standards. It provides complete administrative dashboard boilerplates, including integrated authentication, themed UI layouts, and searchable data tables. The system covers a b

This project provides a framework for managing multi-agent systems, designed to automate complex software development, infrastructure, and business workflows. It functions as a multi-agent workflow orchestrator that routes tasks to domain-specific workers while maintaining state persistence and infrastructure automation. By leveraging large language models, the system decomposes high-level objectives into actionable plans, ensuring that complex operations are executed with consistency and reliability. The framework distinguishes itself through its hierarchical agent registry and policy-driven

Swag is a documentation tool for Go that generates standardized API specification files by parsing declarative annotations within source code. It functions by analyzing source files to extract metadata from comments and function signatures, transforming them into machine-readable formats such as JSON or YAML. This process ensures that technical documentation remains synchronized with the underlying code structure throughout the development lifecycle. The tool distinguishes itself through its ability to perform static source code parsing and type-system reflection, which allows it to map compl

Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform development. It translates high-level source code into C, C++, or JavaScript, allowing developers to produce efficient native binaries or web-compatible scripts from a single codebase. The language emphasizes a clean, indentation-based syntax that simplifies code hierarchy while maintaining the power of a full-featured systems language. What distinguishes Nim is its robust metaprogramming framework, which allows developers to inspect, modify, and generate code structures during th

This project is a comprehensive geographic location dataset and reference library providing standardized data for countries, states, and cities. It serves as a source of truth for regional hierarchies, ISO codes, coordinates, and timezone information, available as both a relational SQL database and a document-based JSON library. The project includes a custom dataset export tool that functions as a filtering engine. This allows for the generation of tailored geographic files in JSON, CSV, and GeoJSON formats by selecting only the specific regions or fields required. The dataset covers global

Primus is a real-time communication abstraction layer and middleware framework. It provides a standardized interface for messaging that allows developers to switch between different transport engines without rewriting application logic, while also serving as a wrapper for managing socket lifecycles. The project distinguishes itself by functioning as a real-time client library generator, producing compatible client-side code based on server configurations. It further organizes data flow through virtual stream multiplexing and the ability to group connections into named communication rooms for

Redoc is an API documentation generator that transforms standard API specification files into interactive, responsive, and highly customizable web-based documentation interfaces. It provides a three-panel layout that includes synchronized navigation, code samples, and search functionality, allowing developers to explore endpoints and schemas directly within a browser-based environment. Beyond rendering, the project functions as an API governance toolkit that enforces structural standards and quality rules across API definitions. It includes a suite of processing utilities for bundling, splitt