Open-source alternatives to Wire

Dagger is a compile-time dependency injection framework for Java and Android that automates object creation and lifecycle management. It functions as a static dependency injector and graph validator, resolving object requirements during the build process to avoid runtime reflection and prevent crashes caused by missing bindings. The framework distinguishes itself by using static analysis and code generation to produce factory classes at build time. It employs qualifier-based type differentiation to manage multiple implementations of the same type and provides scope-based lifecycle management

Fx is a dependency injection framework and application lifecycle manager for Go. It functions as a component model container that automates the instantiation and connection of components by analyzing constructor parameters and return values to resolve complex dependency graphs. The framework distinguishes itself through module-based component bundling, which encapsulates related constructors into reusable units to manage visibility and logic. It provides advanced resolution capabilities, including mapping concrete types to interfaces for decoupling, resolving dependency ambiguities via unique

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

Dagger is a compile-time dependency injection framework for Java and Android applications. It automates the construction and wiring of object graphs by generating static source code during the build process, which eliminates the need for reflection or runtime bytecode generation. The framework distinguishes itself by performing strict validation of the entire dependency structure before the application runs, ensuring that all required bindings are satisfied and identifying circular references early. It manages object lifecycles through scoped containers and supports lazy resolution, allowing

dbtpl is a database model generator and schema introspector that produces type-safe source code and data models from SQL database schemas. It functions as a command line tool that maps SQL types to Go structs and execution functions, while providing a template-based system for creating custom source code and schema definitions. The tool supports multiple database engines, including PostgreSQL, MySQL, SQLite, Oracle, and SQL Server. It distinguishes itself by allowing users to define custom output formats through text templates and the ability to generate compatible model definitions for the D

Micronaut Application Framework

ZIO is a functional effect system for the JVM that models asynchronous and concurrent programs as pure, composable values with typed error handling and dependency injection. Its core identity is built on fiber-based concurrency, where lightweight, non-blocking fibers execute millions of concurrent tasks with structured lifecycle management, and a dual-channel error model that separates expected business failures from unexpected system defects at compile time. The system provides effect-typed dependency injection through a layer-based dependency graph, pull-based reactive stream processing with

This is the open-source Android application for Kickstarter, a crowdfunding platform that connects creators with backers. The app enables users to discover creative projects and campaigns, pledge financial support in exchange for tiered rewards, and share campaign details through social media and messaging platforms. The application is built with a standard Android architecture that combines compile-time dependency injection, reactive data flows, and declarative UI binding. It uses Dagger 2 for wiring together services and repositories, RxJava for managing asynchronous operations, and a Model

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

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

This project is a reference implementation of the Model-View-Presenter (MVP) architecture for Android applications. It focuses on separating business logic from the user interface by decoupling data logic, UI presentation, and view layers. The implementation distinguishes itself through the inclusion of a boilerplate generator that automatically creates the activity, presenter, and view files required for the MVP pattern. It utilizes a compile-time dependency injection framework to manage object lifetimes and a reactive programming workflow to handle asynchronous data streams and event propag

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

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

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 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

MessagePack-CSharp is a high-performance binary serializer for .NET that converts C# objects to and from the compact MessagePack format. It uses compile-time source generation to produce AOT-safe formatters and resolvers, eliminating runtime reflection and enabling ahead-of-time compilation scenarios. The serializer encodes object fields as integer indices instead of string keys, producing compact binary output with deterministic field ordering, and provides stack-allocated reader and writer structs for direct encoding and decoding of MessagePack primitives without heap allocations. The libra

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

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

This library is a declarative validation framework for Rust that enforces data integrity and business rules on structured data models. It utilizes procedural macros to transform attribute-based annotations into executable validation logic, ensuring that data structures adhere to defined constraints before processing. The framework distinguishes itself by performing validation at compile time, which eliminates runtime overhead and provides strict type checking for all rules. It supports recursive traversal of nested data structures and collections, ensuring that every level of a hierarchy is v

Pants is a monorepo build system designed to manage multi-language software projects within a single repository. It functions as a polyglot task runner and distributed build orchestrator, providing a unified interface for executing compilers, linters, and test runners across different programming languages. The system is distinguished by a dependency analysis engine that uses static source code analysis to model software dependencies, removing the need for manual build metadata files. It ensures reproducible builds through hermetic isolation and protects the software supply chain using depend

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

flutterrustbridge is a code generation tool that automatically creates type‑safe Dart bindings for Rust functions, enabling direct cross‑language calls between Flutter and a Rust backend. It provides an async FFI adapter that transforms synchronous Rust functions into Dart async methods with background thread management, a cross‑language object manager that wraps persistent Rust structs as Dart objects preserving state across calls, and trait object interop that converts Rust traits into Dart abstract classes for seamless bidirectional use. The project handles the full lifecycle of integrat

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

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

FastStream is an asynchronous Python framework designed for building event-driven microservices. It provides a unified abstraction layer for interacting with various message brokers, enabling developers to manage event production and consumption through a consistent interface while maintaining access to native provider-specific features. The framework centers on a decorator-based routing model that binds application logic directly to broker topics, supported by a built-in dependency injection container that resolves resources at runtime. The framework distinguishes itself through its deep int

MessagePack-CSharp is a high-performance binary serialization library for .NET applications that converts object graphs into the MessagePack format. It functions as a C# data serialization toolkit and a polymorphic binary encoder capable of handling abstract classes and interfaces using union keys to identify concrete derived types. The library provides a binary format transcoder to transform binary data into human-readable JSON for debugging. It supports ahead-of-time formatter generation to avoid runtime overhead and implements LZ4 binary compression to reduce the size of serialized data.