Open-source alternatives to Tsyringe

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

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

PHP-DI is an inversion of control container designed to manage object lifecycles and dependency resolution within PHP applications. It functions as a centralized registry that automates the wiring of components, allowing for the decoupling of services from their concrete implementations. The library distinguishes itself by utilizing reflection to inspect class constructor signatures, enabling automatic dependency injection without requiring manual configuration for standard scenarios. It supports recursive resolution of dependency graphs and provides mechanisms for lazy object instantiation,

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

Provider is a state management and dependency injection framework for Flutter. It simplifies the sharing of data across a widget tree by using a system that manages the injection of objects and services with automated lifecycle and resource disposal. The framework distinguishes itself through reactive state containers that bridge asynchronous data from streams and futures directly into the component tree. It supports state derivation, allowing new objects to be constructed and synchronized based on values observed from multiple upstream providers. To maintain performance, it provides selectiv

Inject is a dependency injection library for Go that manages object lifecycles and wires application components by automating the provision of dependencies. It functions as a reflection-based container that maps specific values to their corresponding types, enabling the automatic retrieval and injection of objects into application logic. The library distinguishes itself through its ability to perform automatic function invocation, where it inspects function signatures at runtime to resolve and provide required arguments from a central registry. It also supports struct field injection, which p

Modular is a framework for the Flutter ecosystem that provides a structured approach to application architecture through module-based dependency injection and navigation management. It enables developers to organize complex codebases into independent, decoupled units, facilitating the management of shared services and object lifecycles within specific application scopes. The framework distinguishes itself by offering hierarchical dependency scoping and lazy resolution, which allow for the automatic creation and disposal of objects based on the active module or page lifecycle. It also features

mini-spring is a Java dependency injection framework and inversion of control container. It manages the full lifecycle of beans, including instantiation, property population, and scope management, while providing a system for automating the wiring of components. The project implements a Java AOP framework that uses dynamic proxies to intercept method calls for cross-cutting logic. It also functions as a Java component scanner to automatically discover and register managed objects via annotations and as a Java event bus to decouple components through a publish-subscribe multicast system. The

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

Kotlin-inject is a dependency injection framework for Kotlin that utilizes compile-time code generation to construct type-safe object graphs. By processing declarative annotations during the build process, the library eliminates the need for runtime reflection, ensuring that dependency resolution and validation occur before the application executes. The framework distinguishes itself through its native support for Kotlin Multiplatform, enabling consistent dependency management across shared and platform-specific codebases. It provides specialized mechanisms for assisted injection, allowing de

SpringAll is a comprehensive reference library and learning resource for enterprise Java application development. It provides a collection of practical guides, configuration templates, and code examples designed to demonstrate standard architectural patterns within the Spring ecosystem. The project serves as a reference

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

RubyGems is a package manager for the Ruby language, serving as a tool for packaging, distributing, and installing libraries and software extensions. It functions as a dependency resolver and registry client, managing the installation of required libraries and their recursive dependencies to ensure consistent environments across development and production. The system handles the complete package lifecycle, including the building of distributable archives, the compilation of native C extensions for high-performance system integration, and the publishing of stable or prerelease versions to regi

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

Unstated is a React state management library that encapsulates application state and update logic within decoupled containers. It functions as a container-based state store, allowing state and business logic to be organized into standalone classes that trigger component re-renders when data changes. The project serves as a dependency injection framework, enabling specific state container instances to be supplied to the component tree. This mechanism supports the use of mock containers or stubs to facilitate controlled testing and custom configurations. The library covers global state managem

Symfony Translation is a PHP library and framework component for internationalizing applications. It provides a complete system for managing message catalogs, handling locale-aware string translation, and formatting messages using ICU MessageFormat syntax to support pluralization, gender, and conditional selection. The component organizes translatable strings into named domains, supports key-based lookup that decouples source text from localized versions, and offers deferred rendering through translatable objects that store parameters and render only when output is needed. The library disting

Implementation of a bulletproof node.js API 🛡️

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

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

TUnit is a comprehensive C# testing framework, mocking library, and fluent assertion tool. It utilizes source generation for test discovery and mock creation, ensuring compatibility with Native AOT and IL trimming by eliminating the need for runtime reflection and proxies. The framework provides specialized capabilities for integration testing, including the management of distributed application lifecycles, isolated database schemas, and the correlation of telemetry and logs across process boundaries via OTLP. It also includes an HTTP testing utility to intercept network exchanges and mock AP

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

Inject is a dependency injection framework for Go that automates the assembly of complex object graphs. By leveraging runtime reflection, the library dynamically inspects object structures to resolve and populate required dependencies, decoupling component initialization from business logic. The framework manages object lifecycles through both singleton and factory-based provisioning. It maintains a central registry to share singletons across an application for consistent state, while also supporting the creation of unique, private instances to isolate state between different components. To

CPM is a source-based package manager and build tool for CMake that downloads, versions, and integrates external C++ dependencies without requiring an external installation. It functions as a script-based resolution system that fetches remote source code and configures project targets for immediate use within the build process. The project ensures reproducible build workflows through lockfile version pinning and cryptographic hash-based integrity verification of downloaded archives. It supports concurrent development by allowing remote resources to be overridden with local filesystem paths an

Ember.js is a structured JavaScript web framework designed for building scalable web applications. It utilizes a Model-View-Controller architectural pattern and incorporates a component-based UI library, a dependency injection framework, and a client-side routing engine. The framework distinguishes itself through a centralized registry for passing shared services across components and routes, alongside a routing system that maps URLs directly to templates and data models to manage navigation. Its broader capabilities include reactive state synchronization and computation memoization for UI p

QFramework is a Unity game architecture framework designed to separate presentation, system, and data logic. It implements a layered software architecture to manage complex game states and provides a game engine utility library to reduce boilerplate code. The framework is centered on the Command Query Responsibility Segregation pattern, which separates data modification commands from data retrieval queries. It utilizes a dependency injection container to manage the lifecycles and resolution of singletons and modular components, alongside an event-driven system for state synchronization to pre

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