Open-source alternatives to Uber Go Dig

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

Guice is a Java dependency injection framework and component container. It automates object wiring by mapping interfaces to implementations via a central injector, removing the need for manual factory patterns and constructor calls. The framework provides specialized support for aspect-oriented programming, allowing for the interception and modification of method execution to implement shared cross-cutting concerns. It also functions as a persistence manager to coordinate transaction boundaries and manage the lifecycle of entity managers within a dependency-injected environment. Its core cap

BeeHive is a modular architecture framework for iOS applications. It provides a dependency injection container, an event bus middleware, a module lifecycle manager, and a service locator to organize an application into independent functional modules. The framework distinguishes itself by utilizing asynchronous module loading to reduce application startup time and prevent main thread blocking. It employs macro-driven automatic module registration to decouple instantiation from application logic and uses protocol-based service mapping to resolve dependencies without requiring direct imports. T

LoopBack Next is a Node.js API framework used for building REST and multi-protocol APIs. It functions as an OpenAPI server implementation that can either generate machine-readable specifications from code or produce implementation controllers and models from existing specifications. The framework distinguishes itself through a central dependency injection container and a repository-pattern data access layer. This architecture decouples application logic from component construction and persistent storage, allowing for a pluggable system where data sources and business logic are isolated throug

Koin is a dependency injection framework for Kotlin applications that manages object lifetimes and resolves dependencies through a lightweight container. It functions as a multiplatform library, allowing shared object definitions and resource bindings to be reused across different target platforms and source sets. The framework provides a system for resolving dependencies directly within user interface components to decouple business logic from view implementations. It includes a compile-time dependency validator that analyzes dependency graphs during the build process to detect missing bindi

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

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

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

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

RoboGuice is a dependency injection library based on Google Guice, specifically designed for Android applications. It functions as an annotation-processed dependency injection container that automates the delivery of system services and application dependencies into Android components to reduce boilerplate code. The project uses annotation processing to optimize application startup times and initialization. By utilizing compile-time bytecode generation, it reduces the overhead typically associated with runtime reflection during the initialization of the dependency container. The framework ma

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.

This project is a type-safe dependency injection framework for Go that manages application lifecycles and injects dependencies into structures using reflection and metadata tags. It functions as a service lifecycle manager and an interface binding library to decouple service consumption from concrete implementations. The framework utilizes a hierarchical service container, organizing services into a tree of nested scopes where child containers inherit dependencies from their ancestors. It includes a dependency graph visualizer for inspecting relationships and invocation chains, as well as a s

Scrutor is a library that extends the standard Microsoft dependency injection container. It provides tools for automated type discovery, complex registration orchestration, and service decoration capabilities within the .NET ecosystem. The project enables the automatic discovery and registration of types from assemblies based on interfaces or attributes. It also provides a framework for wrapping existing services with decorator classes to add functionality without modifying the original source code. The library covers broad capability areas including assembly scanning workflows, dependency i

Developer Roadmap is a community-driven platform that provides structured, graph-based learning paths for software engineering. It serves as a comprehensive knowledge repository where technical domains are organized into visual sequences to guide professional skill acquisition and career growth. The project distinguishes itself through a collaborative ecosystem that enables users to contribute roadmaps, curate industry best practices, and maintain professional profiles. It integrates diagnostic assessment frameworks to evaluate technical proficiency, helping developers identify knowledge gaps

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

This project is a comprehensive backend framework built on NestJS, designed to accelerate the development of multi-tenant software-as-a-service applications. It provides a production-ready foundation that integrates essential infrastructure, including user authentication, subscription billing, and team management, into a modular, decorator-based architecture. The framework distinguishes itself by offering a complete suite of SaaS-specific orchestration tools, such as a built-in billing engine for managing recurring revenue and a multi-tenant database partitioning system. It also includes a ro

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

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

Martini is a web framework for the Go programming language that provides a toolkit for building web applications. It functions as a routing engine and an HTTP middleware pipeline to map network requests to specific handler functions. The framework is distinguished by its dependency injection system, which automatically resolves and provides requested service types as arguments to handler functions. This allows for the decoupling of business logic from infrastructure by matching requested types against a registry of available services. The project covers a broad range of web capabilities, inc

This project is a cross-platform development framework and managed runtime environment designed for building high-performance applications. It provides a comprehensive toolkit for constructing web services, cloud-native microservices, and desktop applications, utilizing a unified runtime that handles memory management and execution across diverse operating systems. The framework distinguishes itself through a native ahead-of-time compilation toolchain that transforms source code into optimized, self-contained machine code binaries. This capability enables fast startup times and reduced memory

pytest is a testing framework for Python that provides a command-line runner for discovering and executing test suites. It is built on a modular architecture that uses standard language assertions to verify code correctness, automatically inspecting expressions to provide detailed failure reports without requiring specialized assertion methods. The framework distinguishes itself through a dependency injection system that manages setup and teardown logic by automatically resolving and injecting resources into test functions. It also features a hook-based plugin architecture that allows for dee

This project is a comprehensive TypeScript-based boilerplate designed to accelerate the development of Vue 3 web applications. It provides a pre-configured foundation that integrates essential build tools, routing, and state management, ensuring a consistent architectural pattern across the entire codebase. By enforcing strict type safety and standardized coding practices, it serves as a starting point for building scalable and maintainable frontend projects. The framework distinguishes itself through extensive automation and modularity. It features an auto-importing system for components and

This project is the .NET Base Class Library, providing the foundational types and APIs required for .NET applications. It serves as a cross-platform runtime library and a standardized managed API framework, acting as the primary set of namespaces for memory management, collections, and asynchronous programming. The library enables the development of enterprise backend infrastructure and the execution of managed code consistently across different operating systems and hardware architectures. It includes capabilities for cross-platform application deployment using self-contained binaries, frame

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

This project is a comprehensive guide to architectural standards and coding patterns for developing maintainable applications within the Laravel framework. It focuses on clean code standards, applying the single responsibility and DRY principles to ensure codebase predictability and consistency. The guide emphasizes decoupling components by moving business logic into service layers and shifting input validation into dedicated request classes to keep controllers lean. It advocates for the use of a service container and dependency injection to reduce class coupling and improve testability. The

This project is a functional programming library and toolkit for building production TypeScript applications. It provides a system for managing concurrency, error handling, and resource lifecycles using functional effects. The project distinguishes itself through a comprehensive suite of specialized toolkits, including a dependency injection framework for decoupling service implementations, a workflow orchestrator for coordinating durable processes, and a SQL database toolkit for consistent data operations across multiple dialects. It also implements an OpenTelemetry instrumentation library f