Open-source alternatives to Auto

RuoYi is a Spring Boot admin framework designed for building enterprise applications. It provides a foundation for creating management dashboards and orchestrating systems using either monolithic or microservices architectures. The project features a low-code application generator that produces ready-to-compile source code and API documentation based on database table configurations. It implements a role-based access control system to map users and roles to specific menus and buttons for secure resource access. The framework includes capabilities for system health monitoring, real-time perfo

Pkl is a configuration-as-code language used to define, validate, and generate structured configuration files. It functions as a type-safe configuration generator that enforces data integrity through a strongly-typed schema, ensuring configuration values meet defined constraints and types during evaluation. The project distinguishes itself by acting as both a configuration file generator and a binding generator. It transforms high-level programmable definitions into static formats such as JSON, YAML, or XML, and produces language-specific source code to synchronize settings and provide type s

This project is a command-line tool and template-based scaffolding engine that transforms API interface specifications into functional client libraries and server stubs. By automating the creation of type-safe SDKs and boilerplate code, it bridges the gap between service definitions and implementation, allowing developers to maintain synchronized codebases across many programming languages. The tool distinguishes itself through a portable execution model that utilizes containerized build isolation to ensure identical output regardless of the host environment. It features a modular, plugin-bas

JavaParser is a library that parses Java source code up to version 12 into an Abstract Syntax Tree (AST), enabling programmatic analysis, transformation, and generation of Java code. It serves as a parser, code analyzer, code generator, comment parser, and symbol resolver, providing a unified toolkit for working with Java source at the AST level. The library distinguishes itself through several integrated capabilities that go beyond basic parsing. It includes a symbol resolution engine that resolves type and symbol references across files for accurate semantic analysis, and an error-recovery

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

Concurrent Ruby is a comprehensive concurrency toolkit for the Ruby language that provides thread-safe data structures, synchronization primitives, and asynchronous execution patterns. It implements core concurrency abstractions including an actor model framework where isolated actors communicate through asynchronous message passing, a future and promise system for composing non-blocking operations, and thread pool executors that manage reusable worker threads for concurrent task execution. The library distinguishes itself through a broad set of coordination mechanisms that go beyond basic th

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

Jennifer is a code generator for Go

adt4j - Algebraic Data Types for Java

Code generation tools for Go.

This project is a full-stack application generator and Java application scaffolder designed to produce the initial project structure and boilerplate code for modern web applications and microservice architectures. It functions as a development platform that uses predefined technology stacks to automate the creation of backend services and APIs. The system includes a customizable code blueprint tool, allowing users to extend or replace standard generation patterns to modify the default code structure of client and server components. It also provides a containerized development environment to e

An enum generator for go

Versatile Go code generator.

GoWrap is a command line tool for generating decorators for Go interfaces

Derives and generates mundane golang functions that you do not want to maintain yourself

.NET LINQ capabilities in Go

Sbt is a JVM build tool and dependency management system designed for Scala and Java. It functions as a multi-project build orchestrator that manages the compilation of source code, resolves external libraries from remote repositories, and packages binaries for distribution. The project is distinguished by its interactive build system, which provides a read-eval-print loop for real-time state inspection and task execution. It utilizes a dependency-graph based execution model to process tasks and maintains a type-safe key-value store for dynamic build configuration. Its capabilities cover JVM

ET is a C# game server framework and distributed actor model runtime designed for large-scale multiplayer environments. It provides a comprehensive toolkit for building distributed game backends, incorporating a multiplayer network transport layer and a specialized suite for game AI and pathfinding. The framework is distinguished by its use of a distributed actor model to scale processing across multiple threads and servers, utilizing isolated actors for state management and messaging. It features a unified codebase architecture that allows shared logic between the server and client, enabling

Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments. The framework distinguishes itself through a unified approach to reactive and imperative program

Rust-analyzer is a language server implementation that provides real-time code intelligence, static analysis, and development productivity tools for the Rust programming language. It functions as a backend engine that communicates with text editors to deliver deep structural understanding of source code, enabling features like semantic analysis, symbol navigation, and automated refactoring. The project distinguishes itself through a core engine designed for high-performance responsiveness, utilizing incremental query-based compilation and lazy demand-driven evaluation to minimize resource con

MapStruct is an annotation processor and Java bean mapping framework that automatically generates high-performance data transfer code during the compilation process. It serves as a type-safe data mapper for converting information between different object types, specifically targeting Java beans and records. The project replaces manual boilerplate code by using Java interfaces as blueprints to generate concrete implementation classes. This approach ensures type safety and minimizes manual getter and setter calls by producing direct method calls during compilation. The framework handles data t

Mapperly is a C# source generator used for high-performance object-to-object mapping in .NET. It functions as a compile-time mapping library that produces the necessary transformation code during the build process, eliminating the need for runtime reflection when converting between domain models and data transfer objects. The tool distinguishes itself by providing type-safe diagnostic validation and strict mapping enforcement, emitting warnings for unmapped properties at compile time. It includes specialized capabilities for circular reference handling and deep cloning to maintain object iden

KotlinPoet is a Java-based API for programmatically creating and formatting Kotlin source files. It serves as a source code generator and type system mapper, providing a framework to build Kotlin code structures through a type-safe model of language elements to automate the production of boilerplate. The project utilizes a fluent-builder pattern to incrementally construct language elements and maintains an internal object-model representation that separates logical structure from final text formatting. It handles the complexities of source emission through indentation-based formatting and key

AndroidAnnotations is a suite of tools designed to automate the generation of repetitive boilerplate and setup code for mobile application development. It functions as a code generation tool that reduces manual effort by creating the plumbing required to initialize Android components and views. The project provides specialized frameworks for dependency injection, concurrency management, and view binding. It automates the assignment of system services, resources, and UI elements to fields and maps user interface events directly to methods to eliminate the need for anonymous listener classes.

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

This toolkit provides an asynchronous interface for interacting with relational databases, offering a unified driver-agnostic layer for managing connection pools and executing transactions. It is designed to integrate with asynchronous runtimes, enabling non-blocking database operations while maintaining secure, encrypted communication between the application and the database server. The project distinguishes itself through its compile-time validation capabilities, which use procedural macros to inspect SQL syntax and parameter types against a live database schema during the build process. Th

FlatBuffers is a cross-platform serialization library designed for performance-critical applications that require efficient, zero-copy data access. By organizing data in a structured binary format, it allows applications to read and write complex data structures directly from memory-mapped buffers without the need for intermediate parsing or temporary object allocation. The project distinguishes itself through a schema-driven approach that balances high-performance access with long-term data evolution. It utilizes a unique memory layout featuring relative offsets and inline fixed-size structu