Open-source alternatives to Library

This project is a reference implementation for building scalable applications in TypeScript using Domain-Driven Design. It provides a structured codebase template that organizes business logic through tactical design patterns and strategic modeling to ensure the software reflects specific business requirements. The architecture utilizes a hexagonal pattern to isolate core business logic from external infrastructure concerns such as databases and delivery mechanisms. It implements Command Query Responsibility Segregation to separate data modification operations from information retrieval tasks

This project is a full-stack forum platform built with TypeScript that serves as a reference architecture for implementing domain-driven design and clean architecture patterns. It provides a structured environment for community discussion, enabling users to register, authenticate, and engage in moderated conversations across organized topic categories. The platform distinguishes itself by strictly separating core business logic from infrastructure concerns. By utilizing a layered hexagonal architecture and the repository pattern, the codebase isolates business rules from external frameworks a

eShopOnWeb is a reference application for ASP.NET Core that demonstrates a sample e-commerce site. It serves as a template for building scalable services using domain-driven design to separate business logic from infrastructure and data access. The project implements a decoupled messaging pattern through a request pipeline to separate web controllers from application logic. It utilizes a repository pattern to abstract data persistence and isolate the core application logic from the specific database storage mechanism. The application covers a broad surface of web capabilities, including user

This project provides a structured template for building enterprise applications using a modular monolith architecture. It demonstrates how to organize complex business logic into independent, domain-specific modules that remain contained within a single deployment unit. The architecture enforces strict boundaries between components to minimize coupling and complexity. It utilizes domain-driven design principles to map software components directly to real-world business concepts, ensuring that logic remains independent of infrastructure concerns. Communication between these isolated modules i

This project serves as a comprehensive educational resource for implementing modular monoliths and microservices within .NET environments. It focuses on applying domain-driven design principles to manage complex business logic, providing a structured approach to building systems that can evolve alongside changing requirements. The architecture is defined by its emphasis on modularity and clear boundaries, utilizing vertical slices and bounded contexts to organize code by business process rather than technical layer. It distinguishes itself through a systematic migration framework that allows

This project is a reference implementation and architectural sample of Domain-Driven Design. It serves as a codebase demonstrating how to align software design with a specific business domain to manage complex business logic. The implementation functions as a reporting system that receives and processes data via JSON payloads. It utilizes a structured domain model to define and automate business workflows and handle state changes. The architecture partitions the system into distinct application and domain layers, utilizing aggregate roots for consistency and the repository pattern for data a

This project serves as a reference implementation for applying clean architecture principles within a C# environment. It demonstrates how to structure enterprise applications by organizing code into concentric, independent layers that isolate core business logic from external infrastructure, frameworks, and database concerns. The codebase illustrates the application of domain-driven design to center software logic around business entities and rules. It utilizes interface-based decoupling and dependency inversion to ensure that high-level policies remain unaware of low-level implementation det

Commanded is an Elixir framework designed for building event-sourced applications that utilize domain-driven design. It provides a structured environment for implementing command-query responsibility segregation, allowing developers to separate write-side command processing from read-side data projection. By treating state changes as an immutable sequence of events, the framework ensures a reliable audit trail and facilitates system recovery. The project distinguishes itself through its support for distributed process orchestration and event-driven middleware pipelines. It enables the managem

This project provides a structured boilerplate for building Node.js REST APIs, implementing clean architecture principles to isolate business logic from external frameworks and data sources. It serves as a template for organizing complex backend services by enforcing a strict separation of concerns between domain entities, infrastructure, and interface layers. The architecture distinguishes itself through a modular, plugin-based server design built on the Hapi.js framework. It utilizes a dependency injection container to decouple business logic from concrete implementations, ensuring that ser

This project is a reference implementation providing a collection of practical examples for data access patterns and repository abstractions within the Spring Data ecosystem. It serves as a comprehensive showcase for implementing consistent data layers across various relational and non-relational databases. The repository specifically demonstrates multi-store persistence by integrating relational, document, and vector databases within a single application. It includes implementations for vector search to manage high-dimensional embeddings and similarity searches across different database tech

This project is a .NET Clean Architecture template designed to separate domain logic from infrastructure and web frameworks. It provides a project structure for C# applications and a React Redux frontend, creating a testable backend focused on maintainability. The implementation centers on Domain Driven Design, modeling core business domains using entities and value objects to manage complex requirements. It utilizes a decoupled architecture to ensure that business logic remains independent of external frameworks and database technologies. The project covers full stack application bootstrapp

Domain-Driven-Design-Example is a C# sample project and reference pattern that demonstrates how to structure business logic and domain models using domain-driven design principles. It implements enterprise application architecture patterns by isolating core business rules and domain entities from technical infrastructure concerns through bounded contexts. The codebase implements core domain concepts using immutable value objects defined entirely by their attributes, alongside entities and application services. It coordinates external requests, transaction boundaries, and domain model interact

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

This project is a Java microservices reference implementation that demonstrates the application of structural design patterns for distributed systems. It consists of a suite of containerized services and infrastructure dependencies designed to showcase how to coordinate multiple independent services into a functional system. The implementation focuses on several advanced architectural patterns, including a centralized API gateway for routing and aggregating responses, Command Query Responsibility Segregation to separate read and write operations, and event sourcing to persist the state of bus

This project is a framework for implementing event sourcing and command query responsibility segregation within containerized microservices. It provides a structured approach to managing business state as a sequence of immutable events, ensuring a reliable audit trail and the ability to reconstruct system state at any point in time. The framework distinguishes itself by enforcing a clear separation between data modification and data retrieval paths. By utilizing event-driven data synchronization, it allows for the asynchronous updating of materialized views and read models, ensuring that quer

This project is a collection of software engineering principles and architectural design patterns designed to minimize the mental effort required to understand and maintain source code. It serves as a guide for implementing clean code methodologies and architectural simplification to reduce the overall cognitive load on developers. The framework emphasizes aligning module boundaries and ubiquitous language with business stakeholders to prevent architectural ripple effects. It advocates for balancing service granularity to avoid the overhead of distributed monoliths and suggests favoring objec

Behat is a behavior-driven development framework and test automation tool for PHP. It functions as a Gherkin test runner that maps natural language feature files to executable PHP methods to verify that software implementation aligns with business requirements. The framework enables the definition of application behavior using a structured, human-readable format based on user stories, supporting localized keywords for non-English speaking stakeholders. It distinguishes itself through a driver-based browser simulation layer for user interface verification and specialized integrations for the S

This project is an ASP.NET Core solution template and boilerplate that implements a clean architecture pattern for building enterprise applications and web API backends. It provides a standardized project scaffold designed to separate business logic from infrastructure and user interfaces to ensure high testability and low coupling. The project features a database agnostic structure that allows for switching persistence providers without altering core business logic. It includes a command line tool for enterprise application bootstrapping, enabling the automated generation of project structur

Quick is a behavior-driven development framework and testing tool for Swift and Objective-C. It functions as both a testing framework and an assertion library, providing the structures necessary to write and run automated tests. The project focuses on organizing test suites into nested, human-readable requirements to define expected software behavior. This approach allows developers to structure tests in a descriptive format that translates technical requirements into readable specifications. The framework covers functional validation and quality assurance for Apple platform development. It

This project is a TypeScript-based architectural framework designed to implement domain-driven design and hexagonal architecture in enterprise applications. It provides a structured boilerplate that isolates core business logic from infrastructure concerns, ensuring that domain entities, use cases, and external technology adapters remain decoupled and maintainable. The framework distinguishes itself by enforcing strict architectural boundaries and dependency inversion, preventing unauthorized access to core logic from external layers. It utilizes a command-query responsibility segregation pat

EquinoxProject is an ASP.NET 9 web application template and reference implementation for building enterprise software. It provides a structural boilerplate centered on clean architecture, domain-driven design, and the separation of read and write operations through a command query responsibility segregation framework. The project incorporates event sourcing to track the history of business entities as a sequence of events for auditing and state reconstruction. It utilizes a layered approach to decouple business logic from external dependencies and frameworks. The system includes capabilities

This project is a Domain-Driven Design framework and strategic design methodology. It provides a structured workflow for translating business knowledge into technical implementations, guiding the decomposition of complex business domains into manageable software models. The methodology focuses on strategic domain decomposition, identifying core domains to inform build-versus-buy decisions, and defining bounded contexts to establish system responsibilities. It employs collaborative visual techniques to build a shared mental model of the problem domain between technical and non-technical team m

This project serves as a comprehensive guide and collection of architectural patterns for implementing domain-driven design within Java enterprise applications. It focuses on structuring persistence layers to ensure data integrity, maintainability, and clear domain boundaries when working with object-relational mapping. The repository distinguishes itself by demonstrating how to encapsulate business logic and state transitions directly within entities, moving away from simple data containers toward rich domain models. It provides practical examples for managing complex entity relationships, i

This project is a comprehensive educational resource focused on the principles, patterns, and trade-offs required to design scalable, reliable, and high-performance distributed systems. It provides a structured curriculum that covers the fundamental architectural strategies necessary for building modern software infrastructure, ranging from high-level system decomposition to low-level networking and data management. The repository distinguishes itself by offering deep dives into complex architectural patterns, such as microservices-based decomposition, event-driven communication, and command-

Dependency-cruiser is a JavaScript and TypeScript dependency analyzer and architectural linter. It serves as a static analysis tool for mapping, visualizing, and validating module relationships within a codebase without requiring code execution. The project is distinguished by its ability to enforce architectural boundaries through a rule-based system. It detects circular dependencies, identifies orphan modules and dead code, and validates dependency constraints using allowed and forbidden relationship rules. It also provides quantitative stability analysis by calculating afferent and efferen

This project is a software design pattern implementation guide and architecture reference. It provides a practical collection of code examples demonstrating creational, structural, and behavioral patterns to improve software maintainability and quality. The library includes standardized implementations for object instantiation through creational patterns, templates for assembling objects into efficient hierarchies using structural patterns, and examples for managing object communication and responsibility distribution via behavioral patterns. The project maps these abstract design patterns t

Space Station 14 is a C# multiplayer game and roleplay simulation framework. It is built upon an Entity-Component-System (ECS) game engine that separates logic into systems and data into components to manage complex entity interactions. The project functions as a grid-based physics simulator with a YAML data-driven prototype system for defining game objects. The project features a specialized 2D sprite rendering engine that maps server-side appearance data to client-side shaders. It implements a networking model with client-side prediction and dirty-flagged state synchronization to reduce inp