Awesome GitHub RepositoriesClean Architecture Frameworks

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

This project is a comprehensive template for building enterprise-grade applications using clean architecture principles. It provides a structured foundation that decouples core business logic from infrastructure concerns, ensuring that domain entities remain independent of specific frameworks or database implementations. By utilizing a mediator-based request dispatching pattern, the system separates state-mutating commands from read-only queries, promoting a clean separation of concerns across the entire codebase. The architecture is organized into vertical slices, grouping related logic and

This is a reference implementation of Uncle Bob's clean architecture for Android, structured into distinct domain, data, and presentation layers. The project demonstrates how to organize an Android application around business use cases, keeping domain logic and entities free from framework dependencies. The architecture enforces dependency inversion through layered separation, where inner domain layers define interfaces that outer layers implement. This approach enables repository abstractions for data source switching, presenter-view separation for testable UI logic, and use-case composition

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

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

This project is a reference implementation of the Model-View-ViewModel pattern using Android Jetpack components. It serves as an architecture template and layering guide, dividing application code into view, domain, and data layers to ensure a unidirectional flow of dependencies. The implementation focuses on state management and configuration change handling. It demonstrates how to synchronize UI updates across multiple screens using shared state containers and preserves application state during transitions between portrait and landscape orientations. The codebase covers a broad surface of

Pokedex is a reference implementation of an Android application that utilizes the MVVM architecture, Jetpack Compose for its declarative user interface, and Hilt for dependency injection. It serves as a sample project demonstrating a mobile application built with Android Jetpack and a Kotlin Coroutines network client to manage asynchronous data requests. The project implements a modular codebase to optimize build performance and enforce internal boundaries. It features a local persistence layer using the Room library to cache remote data on the device and utilizes Material Motion for fluid in

This project provides a comprehensive collection of best practices, architectural patterns, and coding standards for the .NET ecosystem. It serves as a guide for developers to improve the readability, maintainability, and testability of C# applications by applying established software engineering principles. The repository focuses on enforcing consistent code style and structure through automated configuration rules. It emphasizes the use of SOLID design principles to create modular, loosely coupled components, alongside structured exception management to ensure diagnostic information is pres

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 is a demonstration and template project that applies Clean Architecture principles to SwiftUI application development. It implements a layered architecture that separates presentation, business logic, and data access into independent layers, with unidirectional data flow managed through a single immutable app store that serves as the sole source of truth for all screens. The project distinguishes itself through its implementation of interactor-driven business logic, where all domain rules and workflows live in stateless objects that receive requests and update the central store. Dependen

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

Ce projet est une implémentation de référence de l'architecture Model-View-Presenter pour les applications Android. Il sert d'exemple structurel sur la façon de séparer la logique métier de l'interface utilisateur via un framework basé sur le présentateur. L'implémentation se concentre sur une approche d'architecture propre, utilisant des présentateurs pour servir de médiateur à toute communication entre le modèle de données et la vue. Elle emploie un pattern de vue passive et un découplage basé sur l'interface pour isoler l'interface utilisateur des règles de domaine. L'architecture incorpore une logique de domaine basée sur l'interacteur et une séparation en couches pour réduire le couplage systémique. Cette structure permet des tests unitaires agnostiques à la plateforme, permettant à la logique d'application d'être vérifiée au sein d'une machine virtuelle Java standard sans nécessiter le framework Android ou un appareil physique.

Ce projet est une implémentation de référence des design patterns Domain-Driven Design, de la modélisation de domaine fonctionnelle et de la coordination d'état pilotée par les événements. Il démontre l'application de design patterns stratégiques et tactiques pour gérer des exigences métier complexes. L'implémentation utilise un modèle de domaine fonctionnel avec des fonctions pures et des objets immuables pour gérer les transitions d'état et les effets de bord. Il dispose d'une architecture Command Query Responsibility Segregation (CQRS) pour séparer les modèles de lecture et d'écriture, ainsi qu'une coordination pilotée par les événements pour maintenir la cohérence à travers les limites métier autonomes. La base de code intègre une architecture monolithique modulaire utilisant des contextes bornés (bounded contexts) et un découpage hexagonal pour isoler la logique centrale de l'infrastructure. L'assurance qualité est gérée via une suite de développement piloté par le comportement (BDD) qui reflète le langage omniprésent pour vérifier les scénarios métier et des tests automatisés qui imposent des contraintes architecturales. Le projet applique ces patterns à un domaine de gestion de bibliothèque, couvrant la maintenance du catalogue de livres, les flux de travail de circulation, les validations de réservation et le suivi des retours en retard.

u2020 is an example Android application that demonstrates how to wire together application components using compile-time dependency injection, annotation-driven view binding, and a slide-out debug drawer. The project serves as a real-world showcase for integrating Dagger for dependency injection and Butter Knife for view binding, both of which generate code at compile time rather than relying on runtime reflection. The application features an in-memory mock server that simulates backend responses using static data, enabling development and testing without a live network. A debug drawer overla

BasePopup est une bibliothèque de fenêtres contextuelles Android et un framework de composants UI conçu pour créer des fenêtres flottantes et des superpositions personnalisées au sein des applications Android. Il fournit un ensemble d'éléments réutilisables pour rendre du contenu ciblé et des contrôles temporaires au-dessus de l'écran principal de l'application. La bibliothèque gère la mise en page et l'affichage de ces vues flottantes via un framework personnalisé qui standardise l'apparence et le comportement des menus contextuels. Il implémente spécifiquement la fonctionnalité de fenêtre contextuelle Android pour fournir des options contextuelles sans nécessiter de navigation hors de la page actuelle. Le framework couvre le développement de composants UI via la gestion de fenêtres, le calcul de coordonnées basé sur des vues d'ancrage et l'adaptation dynamique des dimensions. Il gère l'inflation des vues et la gestion des événements pour intégrer ces éléments flottants dans l'interface mobile.

NorthwindTraders est une application exemple ASP.NET Core qui sert d'implémentation de référence pour le développement d'API web RESTful. Elle démontre l'utilisation de l'écosystème .NET pour exposer des fonctionnalités métier via HTTP. Le projet fournit un exemple d'architecture d'application en couches, séparant la logique métier de l'infrastructure et des dépendances externes. Il implémente une couche de données Entity Framework Core utilisant une approche code-first pour mapper les objets de l'application à une base de données relationnelle. L'implémentation couvre les capacités backend fondamentales incluant l'intégration de base de données relationnelle, le routage des requêtes côté serveur et l'organisation des couches d'architecture découplées.

Ce projet est un modèle d'application Android Kotlin de référence et un ensemble d'implémentations exemples démontrant les principes de l'Architecture Propre (Clean Architecture). Il fournit une conception structurelle qui isole les règles métier fondamentales de l'interface utilisateur et des sources de données dans des modules distincts et en couches. L'implémentation se concentre sur le modèle Modèle-Vue-VueModèle (MVVM) pour découpler la logique de l'interface utilisateur des modèles de données. Elle utilise un framework d'injection de dépendances pour automatiser la création d'objets et gérer les cycles de vie des composants, tout en employant un modèle de dépôt (repository pattern) pour abstraire les requêtes de données à travers la mémoire, le disque et les sources cloud. L'architecture intègre une organisation de paquets basée sur les fonctionnalités et des configurations de build modulaires pour maintenir la cohérence sur tout le projet. Elle inclut également une stratégie de test complète qui combine des tests unitaires pour la logique métier avec l'instrumentation pour l'interface utilisateur et des modules de mock pour la validation de la couche de données.

This project is a SwiftUI app template and architectural blueprint for building iOS applications. It implements Clean Architecture and the MVVM pattern to separate business logic, data access, and the user interface into distinct layers. The framework utilizes a dependency injection container to manage object lifetimes and a flow coordinator pattern to handle navigation and screen transitions independently from the view layer. The codebase includes systems for network data management, featuring remote data pagination, cache-backed retrieval, and data mapping via data transfer objects. It als

Ce projet est un modèle d'architecture propre (Clean Architecture) .NET conçu pour séparer la logique de domaine de l'infrastructure et des frameworks web. Il fournit une structure de projet pour les applications C# et un frontend React Redux, créant un backend testable axé sur la maintenabilité. L'implémentation se concentre sur le Domain Driven Design, modélisant les domaines métier principaux à l'aide d'entités et d'objets de valeur pour gérer des exigences complexes. Il utilise une architecture découplée pour garantir que la logique métier reste indépendante des frameworks externes et des technologies de base de données. Le projet couvre le bootstrapping d'applications full stack, l'intégration de l'accès aux données découplé et les tests automatisés de logique métier. L'application est packagée en tant qu'application web conteneurisée pour assurer un déploiement cohérent à travers différents environnements d'hébergement.