Open-source alternatives to Nodejs Clean Architecture App

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

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 provides a structural pattern for organizing React and TypeScript applications by decoupling business logic from user interface components and external infrastructure. It implements a layered architecture that isolates core domain rules, ensuring that the application remains independent of specific frameworks, libraries, or external service implementations. The architecture relies on dependency injection and inversion principles to manage service implementations, allowing for modularity and easier testing. By utilizing a functional core and imperative shell, the system separates

Sunflower is a reference implementation designed to demonstrate modern Android development patterns and industry-standard architectural practices. It serves as a comprehensive guide for building functional mobile applications by integrating declarative user interface toolkits with robust data management and navigation systems. The project distinguishes itself by showcasing the transition from legacy view-based systems to modern declarative frameworks. It provides a practical example of how to organize code into distinct layers, manage complex state, and implement dependency injection to ensur

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

This project is an educational guide focused on building modular web applications using native PHP features. It demonstrates how to construct a functional application architecture from the ground up without relying on external third-party frameworks. The guide centers on implementing core architectural patterns, including a request router that maps incoming HTTP paths to specific controller logic and a dependency injection container that manages object lifecycles and class requirements. By decoupling components through automated dependency resolution, the project emphasizes maintainability an

This is a TypeScript web framework and Node.js backend framework used to build web applications and API servers. It serves as a server-side application toolkit providing a structured environment for managing HTTP routing, request parsing, and application configuration. The framework features a dependency injection container to deliver required objects between application components, decoupling internal logic. It includes built-in tools for server-side data security, such as cryptographic drivers for hashing sensitive data and encrypting application data at rest. The project covers broad capa

Nonebot2 is an asynchronous Python framework for building event-driven chatbots across multiple messaging platforms. It centers on a non-blocking event bus and a driver-based adapter system that unifies different messaging protocols into a single consistent interface. The framework utilizes a modular plugin architecture, allowing for the discovery and loading of third-party extensions to add new event handlers and system capabilities. It distinguishes itself with a type-annotation based dependency injection system that automatically resolves and provides required service objects to handlers 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

Hanami is a full-stack Ruby web framework and API platform designed for building maintainable applications. It centers on a modular web architecture that organizes software into independent slices to prevent monolithic growth and isolate functional units. The framework implements a clean architecture by decoupling business logic from persistence and request handling. This is achieved through a central dependency injection container for managing object lifetimes and a repository pattern mapper that separates domain entities from the persistence layer. The project further provides a Rack-compa

Prism is a XAML application framework and MVVM architectural framework designed to build loosely coupled and testable applications across WPF, Xamarin Forms, and WinUI. It serves as a structural pattern implementation that separates business logic from the user interface to improve maintainability and testing. The framework provides a XAML event bus for exchanging data and triggering actions between independent components without direct coupling. It also functions as a dependency injection integrator, bridging external inversion-of-control containers to manage service delivery across multiple

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

ThinkJS is a server-side web framework designed for building applications on the Node.js runtime. It serves as a development platform that supports TypeScript and the latest ECMAScript standards to create stable and maintainable backend services. The framework employs a layered application architecture that separates concerns into controller, service, and model tiers. It utilizes a dependency-injected service model to manage singleton services and a middleware-based system for request handling and route dispatching. Development is supported by a build pipeline that transpiles modern JavaScri

This project is a boilerplate and template for Go applications implementing Clean Architecture. It provides a standardized project structure designed to organize code into decoupled layers, ensuring that core business logic remains independent of databases, frameworks, and user interfaces. The implementation focuses on a domain-driven design that utilizes dependency injection and the repository pattern to abstract data storage. It enforces architectural boundaries through internal package encapsulation and layer-based dependency inversion. The project includes a development toolchain that au

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

Polka is a minimalist Node.js web framework and HTTP routing engine. It provides a small-footprint server implementation designed for low overhead, mapping URL paths and HTTP methods to specific handler functions. The project utilizes a middleware-based architecture, processing requests through a sequence of functions to handle tasks such as logging, authorization, and data modification. It allows for the organization of these functions into global and path-filtered groups to control execution order. The framework covers core web capabilities including route parameter extraction, request URL

This project is a reference Kotlin Android application template and a set of sample implementations demonstrating Clean Architecture principles. It provides a structural design that isolates core business rules from the user interface and data sources into distinct, layered modules. The implementation focuses on the Model-View-ViewModel (MVVM) pattern to decouple UI logic from data models. It utilizes a dependency injection framework to automate object creation and manage component lifecycles, while employing a repository pattern to abstract data requests across memory, disk, and cloud source

Revel is a full-stack web framework and toolkit for building applications with the Go language. It implements a model-view-controller architecture to separate business logic from user interface rendering, providing a comprehensive system for routing, parameter binding, and session management. The project distinguishes itself with a high-productivity development environment featuring automatic code compilation and hot-reloading, which refreshes the application state and templates upon file changes without requiring manual restarts. It also employs reflection-based parameter binding to automati

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 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 is a reference implementation of Domain-Driven Design patterns, functional domain modeling, and event-driven state coordination. It demonstrates the application of strategic and tactical design patterns to manage complex business requirements. The implementation utilizes a functional domain model with pure functions and immutable objects to manage state transitions and side effects. It features a Command Query Responsibility Segregation architecture to separate read and write models, alongside event-driven coordination to maintain consistency across autonomous business boundaries

Hyperf is a high-performance PHP coroutine framework designed for building microservices and middleware. It utilizes non-blocking coroutines to handle high concurrency and low-latency request processing, providing a foundation for scalable distributed systems. The framework is distinguished by an aspect-oriented programming based dependency injector that enables pluggable components and meta-programming. It includes a coroutine-optimized object-relational mapper with integrated model caching and an orchestration toolkit for microservice governance, featuring service discovery, circuit breaker

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

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 framework provides a structured implementation of the Model-View-Intent pattern for Android applications. It enforces a unidirectional data flow where user intents trigger state updates, which are then propagated through reactive streams to ensure consistent and predictable interface rendering. The architecture relies on immutable state objects to represent application data, ensuring that updates are handled as complete replacements rather than partial modifications. By leveraging Kotlin Coroutines and reactive stream primitives, the framework coordinates asynchronous background tasks an