Open-source alternatives to Dagger

AndroidAnnotations is a boilerplate generator and component annotation library designed for Android development. It functions as a dependency injection framework that uses custom annotations to automate the wiring of activities, fragments, and services. The project focuses on reducing manual plumbing through the automation of Android boilerplate. It provides automated solutions for dependency injection and view binding, removing the need for repetitive calls to locate UI elements or manually write factory classes. The library covers activity lifecycle management and the generation of standar

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

InversifyJS is an inversion of control framework and dependency injection library for TypeScript. It provides a centralized container to manage object lifecycles and automate the instantiation of classes and their dependencies. The library decouples software components by mapping unique identifiers to concrete implementations. This architecture separates object creation from business logic and allows for the replacement of real service implementations with mock objects during unit testing. The framework utilizes TypeScript decorators to provide metadata-driven injection and recursive depende

Awilix is a JavaScript dependency injection framework and inversion of control container. It provides a centralized system for registering and resolving services, decoupling application components by automating how dependencies are created and passed to the functions or classes that require them. The framework features an automatic module loader that scans the filesystem using glob patterns to register dependencies based on filenames and exports. It supports parameter-name-based injection and proxy-based resolution to manage how dependencies are delivered to constructors and functions. The s

TypeDI is a TypeScript dependency injection container and inversion of control tool. It functions as a centralized registry and service locator that manages object instantiation and decouples component dependencies using type inference and decorators. The project provides scoped dependency management to isolate service instances within specific contexts, preventing data leakage between different execution flows. It supports flexible service resolution through the use of type-safe tokens and the ability to map unique identifiers or class constructors to specific service instances. The contain

Autofac is a dependency injection framework and inversion of control container for .NET. It functions as a component registration engine that decouples class implementations from their dependencies by injecting required services via constructors or properties. The project includes an assembly scanning library to automatically discover and register components within compiled binaries based on specific type criteria. It provides a service lifetime manager to control object memory duration using singletons, instance-per-dependency, or isolated request scopes. The framework covers a broad range

Tivi is a cross-platform application for discovering and tracking television shows, built with Kotlin Multiplatform and Compose Multiplatform to share its user interface across Android, iOS, and desktop platforms. The app follows the Model-View-Intent (MVI) architecture pattern, where user actions are modelled as sealed class intents that reduce into a single immutable state object, ensuring predictable and unidirectional data flow managed through Kotlin coroutines and StateFlow. The application uses Hilt for compile-time dependency injection and SQLDelight for type-safe local data storage, c

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.

Small-Spring is a simplified Java implementation of the Spring framework designed to study the internal architecture of inversion of control containers and dependency injection frameworks. It functions as a bean container that manages object lifecycles and resolves dependencies through automated instantiation and property injection. The project implements a mechanism for intercepting method calls using dynamic proxies to support aspect-oriented programming. It separates cross-cutting concerns from business logic by wrapping target objects to modify method executions. The system covers compon

This project is a curated collection of technical interview questions and detailed answers designed for professional software engineering roles. It serves as an Angular framework study resource and interview guide for developers preparing for frontend engineering assessments. The resource covers core architectural patterns including component-based view architecture, hierarchical dependency injection, and declarative template binding. It also addresses implementation details regarding observable-driven data streams and the use of directives for DOM manipulation. Additional content focuses on

This project is a comprehensive Python coding guide and software engineering resource focused on professional development practices. It provides a detailed collection of idiomatic techniques, design patterns, and architectural strategies to improve code quality and maintainability. The guide emphasizes advanced design patterns such as dependency injection, data-driven design, and the application of SOLID principles for object-oriented design. It distinguishes itself by covering sophisticated structural strategies, including class-based decorators, the separation of interfaces from implementat

ARouter is a framework for Android applications designed to decompose monolithic apps into smaller, independent modules. It provides a URL-based routing system that enables navigation between decoupled components and modules without requiring direct class dependencies. The framework includes a navigation interceptor to handle authentication, redirection, and custom activity animations during page transitions. It also features a service injector that manages dependencies across modules using an inversion of control pattern and interface-based injection. The toolset covers inter-module navigat

GetX is a comprehensive state management framework for Flutter that provides a toolkit for managing application state, dependency injection, and routing without requiring build context. It serves as a core architectural system for reactive state management, navigation, service location, and multi-language theme support. The project is distinguished by its ability to handle context-free navigation and the use of observable variables that automatically trigger user interface updates. It features a dependency injection container with lazy loading and automated memory management, alongside a rout

This project is a shared technical specification and standard interface for dependency injection containers in PHP. It defines a common set of interfaces for retrieving services and dependencies, ensuring that different container implementations remain interoperable across the PHP ecosystem. By establishing a standardized API for dependency retrieval, the project allows developers to create libraries that function with any compliant container. This prevents vendor lock-in and enables different container implementations to be swapped without requiring changes to the application code. The spec

Pokedex is a reference implementation of an Android application that utilizes the MVVM architecture, Jetpack Compose for its declarative user interface, and Hilt for dependency injection. It serves as a sample project demonstrating a mobile application built with Android Jetpack and a Kotlin Coroutines network client to manage asynchronous data requests. The project implements a modular codebase to optimize build performance and enforce internal boundaries. It features a local persistence layer using the Room library to cache remote data on the device and utilizes Material Motion for fluid in

This project is a collection of reference implementations demonstrating recommended patterns for organizing code and managing data flow in Android applications. It provides structural examples of layered architecture, separating code into presentation, domain, and data layers to decouple business logic from data sources. The repository includes specific samples for implementing declarative user interfaces that automatically update their visual state based on underlying data changes. It further demonstrates how to manage object lifetimes and component dependencies to reduce boilerplate and sim

EffectiveAndroidUI is a collection of reference implementations and sample projects demonstrating Android UI architectural patterns, navigation strategies, and resource management techniques. It provides practical examples of implementing Model-View-Presenter and Model-View-ViewModel patterns to separate business logic from the user interface. The project features demonstrations of centralized screen transition logic and communication between fragments. It includes examples of resource management using custom qualifiers to organize assets and adapt layouts based on screen density and size. T

This project is an educational platform and tutorial series designed to teach the Go programming language through the practice of test-driven development. It provides a structured path for developers to master language fundamentals, concurrency, and standard library usage by building functional applications in small, verifiable increments. The core methodology centers on the test-driven development cycle, where failing tests are written before implementation to define requirements and ensure code correctness. This approach is applied across a wide range of practical scenarios, including the c

This project is a reference implementation of Domain-Driven Design, Clean Architecture, and Command Query Responsibility Segregation (CQRS) patterns using the Go programming language. It serves as a sample application to demonstrate how to decouple core domain rules from infrastructure and delivery mechanisms. The system is built as a gRPC microservices architecture, utilizing type-safe communication and service contracts. It implements an event-driven architecture to manage eventual consistency and asynchronous processing, specifically employing the Outbox pattern to ensure reliable messagin

GraphQL.NET is a server-side framework for building and executing GraphQL APIs within C# applications. It provides a comprehensive toolkit for schema building, a federated engine for distributed data graphs, and a subscription handler for managing real-time data streams. The project distinguishes itself with a flexible schema builder that supports both programmatic code-first definitions and declarative schema-first approaches using the standard schema definition language. It includes a dedicated federation engine to split data graphs into subgraphs and compose them into a unified gateway, as

This project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of practical examples and projects that demonstrate how to build web applications, RESTful APIs, and high-performance services. The repository focuses on a variety of architectural patterns, including the development of Minimal APIs, contract-first gRPC services, and real-time communication using WebSockets and Server-Sent Events. It includes detailed implementations for user identity and security, such as token-based authentication and CSRF protection. The codebase covers a bro

This is a dependency injection framework and inversion of control container for Python. It decouples object creation from business logic by managing how services and their dependencies are assembled, delivered, and linked within an application. The framework is distinguished by its ability to perform automated component wiring, using import hooks and decorators to inject dependencies into functions and classes across different modules. It supports non-blocking flows through an asynchronous dependency resolver and manages the initialization and shutdown sequences of shared external resources a

dig is a reflection-based dependency injection framework and object graph resolver for Go. It functions as a container that automatically satisfies type dependencies and manages the instantiation of complex networks of objects during application startup. The project utilizes a directed acyclic graph to determine the necessary sequence for object instantiation and employs interface-driven provider mapping to decouple concrete implementations from their satisfied interfaces. It resolves the object hierarchy through reflection-based type resolution and single-pass component wiring to ensure all

This repository is a collection of Swift programming examples and an iOS app architecture reference. It provides a set of small applications and refactored projects that demonstrate the practical application of the Swift language, system frameworks, and user interface components. The project serves as a design pattern reference for implementing professional software architecture. It covers the application of Model-View-ViewModel, protocol-oriented programming, and dependency injection to decouple components and increase code reuse. Additional resources focus on test-driven development, provi

This project is a reference Kotlin Android application template and a set of sample implementations demonstrating Clean Architecture principles. It provides a structural design that isolates core business rules from the user interface and data sources into distinct, layered modules. The implementation focuses on the Model-View-ViewModel (MVVM) pattern to decouple UI logic from data models. It utilizes a dependency injection framework to automate object creation and manage component lifecycles, while employing a repository pattern to abstract data requests across memory, disk, and cloud source

ASP.NET Core is a unified, cross-platform framework designed for building scalable web applications and services. It provides a comprehensive environment for constructing server-side rendered applications, real-time communication services, and interactive web components using C# and .NET. The framework distinguishes itself through a modular architecture that centers on a built-in dependency injection container, which manages service lifecycles and component modularity to improve testability. It utilizes a middleware pipeline to process requests and employs policy-based authorization to secure

This project is a PHP dependency injection container and framework designed to centralize object construction and manage class dependencies. It serves as a service container and configuration registry that automates object lifecycles and manages references between services to decouple application components from their specific dependencies. The system handles the instantiation and wiring of objects through both constructor and setter injection. It provides a centralized registry for storing reusable parameters and service definitions, which prevents the hardcoding of settings across the appli