Open-source alternatives to Core

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

language-ext is a functional programming framework for C# that provides a suite of immutable data structures and monadic types. It enables the implementation of pure functional programming patterns, utilizing containers to manage side effects, optional values, and error handling. The library is distinguished by its advanced concurrency and state management tools, including a software transactional memory system and lock-free atomic references. It also provides specialized utilities for distributed systems, such as vector clocks for causality tracking and deterministic data conflict resolution

Inngest is a durable execution framework and event-driven automation engine designed to orchestrate background workflows. It enables developers to build resilient, stateful processes by memoizing function steps, ensuring that long-running tasks can automatically resume from the last successful operation after failures, timeouts, or infrastructure restarts. The platform distinguishes itself through its event-driven architecture, which uses a schema-validated bus to trigger functions and coordinate complex, multi-step logic. It employs an onion-model middleware approach for cross-cutting concer

Trigger.dev is a platform for building durable, event-driven background workflows. It functions as a workflow engine that allows developers to define complex, long-running processes using standard code rather than proprietary configuration languages. By utilizing a durable execution model, the system checkpoints progress, ensuring that tasks can automatically resume from the exact point of failure after a crash or interruption. The platform distinguishes itself through its focus on stateful, multi-step automation and real-time feedback. It supports the orchestration of AI agents and external

Litestar is a high-performance Python ASGI web framework designed for building asynchronous APIs and web services. It functions as a type-safe toolkit that leverages Python type hints to provide automatic request validation and response serialization, while natively generating interactive API documentation based on the OpenAPI specification. The framework is distinguished by its integrated dependency injection system, which manages shared resources and resolves complex nested service chains directly within request handlers. It further organizes API development through class-based controllers

Mastra is an orchestration framework designed for building, deploying, and managing autonomous AI agents and multi-agent systems. It provides a comprehensive suite of primitives for creating resilient AI applications, including durable workflow orchestration, event-driven agent loops, and semantic memory management. By integrating these core components, the platform enables developers to build complex, multi-step processes that can reason about goals and execute tasks without manual intervention. The framework distinguishes itself through its focus on observability and secure, isolated execut

PydanticAI is a Python framework designed for building production-grade autonomous agents. It provides a unified interface for interacting with diverse language models, enabling developers to construct agents that perform complex tasks through structured data validation, tool execution, and multi-turn conversation management. The library centers on type-safe schema enforcement, ensuring that model inputs and outputs remain consistent and reliable throughout the agent's lifecycle. The framework distinguishes itself through a robust architecture that emphasizes modularity and testability. It ut

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

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

RoadRunner is a high-performance application server and process manager designed to serve PHP applications using a persistent worker model. It eliminates bootload overhead and initialization time by keeping application processes alive between requests, acting as a protocol-agnostic proxy that routes traffic to a pool of supervised workers. The server is built with a plugin-based modular architecture, allowing it to be extended with custom Go plugins and compiled into tailored binaries. It distinguishes itself by providing a unified execution model for a wide array of communication protocols,

This project is a Python framework for building autonomous, event-driven agent systems. It provides a unified runtime for orchestrating multi-agent workflows, managing persistent conversation state, and executing code within secure, isolated sandbox environments. The framework is designed to handle complex task delegation, allowing agents to invoke other agents as tools while maintaining context across multi-turn interactions. The framework distinguishes itself through its deep integration with the Model Context Protocol, enabling agents to connect to external data sources and remote services

OpenObserve is a unified observability data platform designed to ingest, store, and analyze logs, metrics, and traces. It functions as a cloud-native monitoring tool that centralizes telemetry from diverse sources, including standard collectors and cloud service providers, into a single, scalable system. By utilizing a columnar storage engine backed by object storage, the platform enables efficient long-term data retention and high-performance analytical querying. The platform distinguishes itself through deep integration with artificial intelligence, allowing users to query data using natura

Osquery is a unified endpoint monitoring framework that exposes operating system internals as relational tables. By representing hardware, network, and process activity as structured data, it allows users to retrieve system state and configuration information using standard SQL syntax. The system distinguishes itself through a cross-platform abstraction layer that normalizes disparate operating system interfaces into a consistent schema across Windows, macOS, and Linux. It supports both interactive local analysis via a command-line shell and distributed fleet orchestration, where recurring qu

FastMCP is a Python framework designed for building servers that expose functions, resources, and prompts to AI models using the Model Context Protocol. It simplifies the development process by automatically deriving tool metadata, input schemas, and documentation directly from Python function signatures and type hints. The framework provides a unified container for managing these components, allowing developers to build modular applications that integrate seamlessly with AI assistants. The project distinguishes itself through its support for interactive, server-defined user interface compone

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

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

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

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 an edge computing development toolkit and serverless command line interface used to develop, test, and deploy serverless functions to a global edge network. It serves as an edge runtime bundler and resource orchestrator, managing the entire lifecycle of edge projects from local development to worldwide distribution. The toolkit distinguishes itself through distributed workflow management, coordinating stateful instances and the durable execution of long-running processes across the edge. It also provides specialized integrations for edge AI, including the management of vector

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

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

PureScript is a statically typed, purely functional programming language that compiles to JavaScript. It is designed as a cross-platform frontend language for building safe web applications, utilizing a static type system and a JavaScript compiler to ensure program correctness across browser and server environments. The language is distinguished by its emphasis on mathematical purity, featuring a robust type system with first-class support for monads. It provides a sophisticated toolset for static verification, including algebraic data types, type classes, and automatic type inference to reje

This is a Swift state management framework and application logic library designed for building applications with a single source of truth and unidirectional data flow. It provides a Redux-inspired architecture that separates business logic from side effects and user interfaces to ensure predictable application behavior across multiple screens. The framework focuses on modularity by allowing complex features to be decomposed into smaller, isolated components. This enables the development of UI-independent business logic that can be extracted into separate modules to improve compilation speed a

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

Implementation of a bulletproof node.js API 🛡️

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

Arrow is a functional programming library for Kotlin that provides tools for implementing data-oriented programming patterns. It serves as a framework for typed error handling, a concurrency toolkit, and a library for the manipulation of immutable data. The project distinguishes itself through specialized capabilities for managing application failures using explicit types instead of exceptions and implementing resilience patterns such as circuit breakers and retry policies for distributed services. It also provides optics to update and query deeply nested immutable data structures without man