Projects sharing features with EquinoxProject

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

COLA is a core architectural toolkit for Java applications designed around domain-driven design and a clean, object-oriented layered architecture. It provides a framework for managing project structures, implementing domain-driven entity modeling, and organizing enterprise application architecture to decouple business logic from technical dependencies. The project features a pluggable logic extension system that allows for the addition of new functionality through defined extension points without modifying the core codebase. It also includes a project bootstrapping toolkit and an integration

Util is a comprehensive development framework for .NET designed to implement layered architectures and domain driven design. It provides a toolkit of base classes and tools for building full stack applications, specifically focusing on the creation of backend admin frameworks and management interfaces. The project distinguishes itself through a boilerplate generator that produces the necessary types and classes to standardize repetitive architectural patterns. It also includes a micro-frontend orchestrator that enables the splitting of large frontend modules into independent projects for sepa

This project is a reference implementation for structuring Java applications using clean architecture and domain-driven design principles. It provides a template for organizing code into concentric layers, ensuring that core business rules and domain entities remain entirely independent of external frameworks, databases, and delivery mechanisms. The architecture relies on the dependency inversion principle to decouple business logic from infrastructure. By defining abstract interfaces for data access and external services, the system allows for the replacement of underlying technologies witho

This project is a Swift iOS architecture template that implements the Clean Architecture pattern. It organizes software into distinct layers to decouple business rules from external frameworks, user interfaces, and infrastructure to improve testability and maintenance. The template incorporates Domain Driven Design to isolate core business logic and utilizes a modular application structure to divide features into independent modules. It employs the Coordinator pattern to remove routing logic from view controllers and a dependency injection framework to ensure components remain independent and

Rails Event Store is a library for implementing event sourcing and command query responsibility segregation patterns within Ruby applications. It functions as a framework for capturing all application state changes as an immutable sequence of events, providing a permanent and verifiable history of system operations. The library provides a messaging infrastructure that decouples business logic by broadcasting domain events through a central bus. This architecture allows for the execution of handlers either immediately or asynchronously, ensuring that heavy processing tasks do not block the pri

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

NorthwindTraders is an ASP.NET Core sample web application that demonstrates the implementation of business logic and request handling. It is structured as a layered architecture web app, decoupling core application rules from the user interface and data access layers. The project utilizes Entity Framework Core for its database implementation, employing a code-first relational database approach. This allows the database schema to be generated and evolved automatically from C# entity models via an object-relational mapper. The application manages relational data and serves web requests throug

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

ArchUnit is a Java architecture testing library and automated validator that analyzes compiled bytecode to verify that source code adheres to predefined design rules. It functions as a testing framework that fails builds when the actual code structure violates architectural constraints. The library uses a fluent rule specification to define constraints and employs bytecode analysis to inspect class relationships and package dependencies. This allows for the automated detection of circular dependencies and the enforcement of dependency rules between packages. The tool covers a range of struct

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

Blog.Core is a production-ready backend boilerplate for building enterprise APIs and microservices using ASP.NET Core. It provides a foundational infrastructure for distributed systems, including tools for database-first scaffolding and the implementation of multi-tenant API frameworks. The project distinguishes itself through automated data layer generation, which produces entity models and repository layers directly from database schemas. It implements a centralized identity management system using standard identity server protocols to handle authentication and authorization across multiple

This project provides a standardized architectural framework for building scalable, full-stack enterprise applications. It serves as a foundational boilerplate that enforces clean architecture principles, ensuring that business logic remains isolated from infrastructure concerns and external data persistence details. By organizing code into feature-based modules rather than technical roles, the framework simplifies navigation and maintenance within large, complex codebases. The architecture distinguishes itself through a mediator-based communication model that decouples application layers and

This project is a reference implementation and template for a modular iOS application using SwiftUI and Clean Architecture. It provides a structure organized into independent layers to decouple the user interface and external frameworks from core business logic. The architecture incorporates Domain-Driven Design to manage complexity by organizing code into independent modules based on business domains. This approach enforces strict dependency boundaries and improves build times. The project implements a plugin-based data layer that hides API and database implementations behind gateways to al

This project is an application framework and boilerplate for enterprise web applications based on ASP.NET Core. It provides a foundation for building large-scale business applications by implementing a domain-driven design framework that organizes application logic into decoupled layers and modules. The framework distinguishes itself through built-in support for multi-tenant software-as-a-service architectures, providing primitives for data, configuration, and interface isolation for multiple customers within a single instance. It also includes an integrated identity management system featuri

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

NorthwindTraders is an ASP.NET Core sample application that serves as a reference implementation for developing RESTful web APIs. It demonstrates the use of the .NET ecosystem to expose business functionality over HTTP. The project provides an example of a layered application architecture, separating business logic from infrastructure and external dependencies. It implements an Entity Framework Core data layer using a code-first approach to map application objects to a relational database. The implementation covers core backend capabilities including relational database integration, server-s

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

ABP is an opinionated architectural framework for building enterprise software solutions using .NET and ASP.NET Core. It serves as a structural toolkit for implementing domain-driven design and microservices patterns, providing a modular enterprise architecture where functionality is organized into independent, pluggable modules. The platform is specifically designed to support multi-tenant SaaS architectures, isolating data and configurations for multiple independent customers within a single application instance. It provides enterprise boilerplate infrastructure and pre-configured templates

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

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

This project is a comprehensive library of reference implementations and patterns for building web applications using the Go Fiber framework. It provides curated templates and implementation guides for creating REST APIs, web servers, and structured backend services. The repository serves as a practical resource for applying architectural patterns, including Clean and Hexagonal architectures, as well as port-and-adapter decoupling. It offers detailed examples for integrating common web features such as OAuth2 authentication, JWT verification, WebSockets for real-time communication, and server

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

This project is a reference implementation of domain-driven design patterns and a sample of command query responsibility segregation. It provides a collection of event-driven microservices that demonstrate the practical application of architectural principles for structuring complex software systems. The implementation separates read and write models through an event journal and organizes services into bounded contexts to maintain clear functional boundaries. It coordinates business logic by dispatching and consuming domain events to synchronize different modules. The project covers a range

This project provides a structured template for building enterprise-grade applications using domain-driven design principles. It serves as a foundational scaffold for web services, enforcing a strict separation of concerns by isolating core business logic from infrastructure, data access layers, and external frameworks. The architecture is built around a modular design that utilizes request pipelining and dependency inversion to maintain loose coupling. It distinguishes itself through a centralized command and query handling system, which routes requests through a unified interface, and a dom

This project is a technical resource and pattern library for building enterprise applications with Python. It serves as a guide for implementing clean architecture, providing a framework for separating core business logic from infrastructure and external frameworks. The material focuses on Domain-Driven Design and the application of architectural patterns to maintain complex business requirements. It provides specific guidance on the Repository pattern for data abstraction, Command-Query Responsibility Segregation for optimizing read and write paths, and the use of dependency inversion to dec

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