# Flutter application architecture template

> Search results for `flutter clean architecture` on awesome-repositories.com. 102 total matches; showing the first 50.

Explore on the web: https://awesome-repositories.com/q/flutter-clean-architecture

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [this search on awesome-repositories.com](https://awesome-repositories.com/q/flutter-clean-architecture).**

## Results

- [nalexn/clean-architecture-swiftui](https://awesome-repositories.com/repository/nalexn-clean-architecture-swiftui.md) (6,571 ⭐) — 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
- [khannedy/golang-clean-architecture](https://awesome-repositories.com/repository/khannedy-golang-clean-architecture.md) (1,066 ⭐) — This project provides a structured boilerplate for building Go web applications based on clean architecture principles. It serves as a template for organizing codebases to ensure that core business logic remains isolated from external frameworks, database layers, and delivery mechanisms.

The implementation prioritizes domain-driven design by centering the application around pure business entities that contain no references to infrastructure concerns. It utilizes layered dependency inversion and interface-based port adaptation to decouple the internal logic from external dependencies, allowing
- [matthewrenze/clean-architecture-demo](https://awesome-repositories.com/repository/matthewrenze-clean-architecture-demo.md) (1,217 ⭐) — 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
- [brianegan/flutter_architecture_samples](https://awesome-repositories.com/repository/brianegan-flutter-architecture-samples.md) (8,920 ⭐) — This is a reference project that implements the same TodoMVC application across multiple Flutter state management and architecture patterns, enabling direct side-by-side comparison. The project demonstrates how different approaches—including BLoC, Redux, MobX, Provider, and Scoped Model—handle state, data flow, and separation of concerns within the Flutter framework.

Each architecture implementation is built to the same specification and runs an identical suite of shared integration tests, ensuring consistent behavior across all patterns. This allows developers to evaluate the trade-offs of e
- [ivanpaulovich/clean-architecture-manga](https://awesome-repositories.com/repository/ivanpaulovich-clean-architecture-manga.md) (4,334 ⭐) — 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
- [bespoyasov/frontend-clean-architecture](https://awesome-repositories.com/repository/bespoyasov-frontend-clean-architecture.md) (2,575 ⭐) — 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
- [mattia-battiston/clean-architecture-example](https://awesome-repositories.com/repository/mattia-battiston-clean-architecture-example.md) (1,776 ⭐) — 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
- [amitshekhariitbhu/go-backend-clean-architecture](https://awesome-repositories.com/repository/amitshekhariitbhu-go-backend-clean-architecture.md) (6,059 ⭐) — This is a Go backend template that structures a web service into domain, usecase, controller, and repository layers with strict dependency inversion. It provides a foundation for building maintainable and testable REST APIs by separating business logic from transport and data access concerns.

The project implements JWT-based authentication, issuing access and refresh tokens for user signup, login, and protected endpoint access. It uses the Gin HTTP framework to build a Docker-packaged REST API with public and private route groups, request validation, and middleware-based authentication. Depen
- [kudoleh/ios-clean-architecture-mvvm](https://awesome-repositories.com/repository/kudoleh-ios-clean-architecture-mvvm.md) (4,391 ⭐) — 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
- [jbuget/nodejs-clean-architecture-app](https://awesome-repositories.com/repository/jbuget-nodejs-clean-architecture-app.md) (1,540 ⭐) — 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
- [flutter/flutter](https://awesome-repositories.com/repository/flutter-flutter.md) (177,056 ⭐) — This project is a multi-platform UI framework designed for building applications that target mobile, web, and desktop environments from a single codebase. It utilizes a declarative paradigm where the user interface is defined as a function of application state, supported by a layered architecture that includes a high-performance rendering engine and a multi-platform compilation model.

The framework provides a comprehensive suite of developer tools, including hot reloading for real-time code injection and diagnostic utilities for monitoring application state and performance. It features a modu
- [rafaelfgx/architecture](https://awesome-repositories.com/repository/rafaelfgx-architecture.md) (3,268 ⭐) — 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
- [clean-css/clean-css](https://awesome-repositories.com/repository/clean-css-clean-css.md) (4,201 ⭐) — Clean-CSS is a Node.js CSS optimizer that functions as a minifier, bundler, and post-processor. It is designed to decrease total stylesheet volume by removing whitespace, comments, and redundant code.

The project provides a pipeline for applying custom transformations and browser compatibility adjustments. It allows for the programmatic modification of CSS rules and values through a plugin system and the use of custom optimization plugins.

The tool covers a broad range of asset optimization capabilities, including stylesheet bundling, import rule inlining, and relative URL rebasing. It also
- [pcah/python-clean-architecture](https://awesome-repositories.com/repository/pcah-python-clean-architecture.md) (533 ⭐) — A Python toolkit for applications driven by The Clean Architecture
- [grab/front-end-guide](https://awesome-repositories.com/repository/grab-front-end-guide.md) (15,235 ⭐) — This project is a front-end development study guide and technical roadmap designed to introduce the tools, libraries, and patterns used in modern web application development. It serves as an educational resource covering single page application architecture, the integration of modern web tech stacks, and the design of components using static typing.

The guide focuses on the orchestration of front-end CI/CD pipelines, providing a walkthrough for automating the linting, testing, bundling, and deployment of static assets to cloud hosting. It specifically addresses the implementation of reusable
- [facebook/flux](https://awesome-repositories.com/repository/facebook-flux.md) (17,464 ⭐) — Flux is an application architecture framework and client-side state orchestrator. It implements a unidirectional state management pattern to ensure data flows in one direction, preventing unpredictable state changes and maintaining consistency across the user interface.

The system functions as an action-driven state architecture where changes are triggered by plain object actions. A centralized dispatcher routes these actions to multiple data stores, which partition the application state and notify views of changes via a publisher-subscriber synchronization pattern.

This approach provides a
- [eduardomoroni/react-clean-architecture](https://awesome-repositories.com/repository/eduardomoroni-react-clean-architecture.md) (1,618 ⭐) — A realistic approach to implement clean architecture on react codebases
- [aksonov/react-native-router-flux](https://awesome-repositories.com/repository/aksonov-react-native-router-flux.md) (8,927 ⭐) — This project is a cross-platform mobile navigation library and declarative routing engine. It maps components to named scenes within a centralized configuration to manage application flow and screen transitions.

The system distinguishes itself through a variety of specialized navigation patterns, including a mobile drawer navigation system for side menus and a tab navigation framework for organizing top-level views. It also features a modal overlay manager for rendering screens as pop-ups or transparent lightboxes and a deep linking handler that maps incoming URIs to specific application scen
- [thangchung/clean-architecture-dotnet](https://awesome-repositories.com/repository/thangchung-clean-architecture-dotnet.md) (1,349 ⭐) — 🕸 Yet Another .NET Clean Architecture, but for Microservices project. It uses Minimal Clean Architecture with DDD-lite, CQRS-lite, and just enough Cloud-native patterns apply on the simple eCommerce sample and run on Tye with Dapr extension 🍻
- [mohamedbouattour/angular-clean-architecture](https://awesome-repositories.com/repository/mohamedbouattour-angular-clean-architecture.md) (3 ⭐) — A CLI tool to scaffold Angular 20+ applications following Clean Architecture principles and NgRx SignalStore best practices.
- [jorgebucaran/hyperapp](https://awesome-repositories.com/repository/jorgebucaran-hyperapp.md) (19,211 ⭐) — Hyperapp is a functional JavaScript framework for building hypertext applications. It centers on a state management library and a virtual DOM system that creates in-memory interface representations to apply efficient updates to the browser screen via diffing.

The framework avoids templates and JSX, instead utilizing function composition and dedicated tag wrappers to generate HTML structures and SVG elements. It implements a unidirectional data flow where a central state object is managed through transformation functions.

The system covers declarative UI rendering and functional web interfaci
- [eminetto/clean-architecture-go-v2](https://awesome-repositories.com/repository/eminetto-clean-architecture-go-v2.md) (1,319 ⭐) — Clean Architecture sample
- [kotlin-android-open-source/mvi-coroutines-flow](https://awesome-repositories.com/repository/kotlin-android-open-source-mvi-coroutines-flow.md) (1,106 ⭐) — 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
- [reflux/refluxjs](https://awesome-repositories.com/repository/reflux-refluxjs.md) (5,323 ⭐) — Refluxjs is a state management library designed to implement a unidirectional dataflow architecture. It manages application state through a strict cycle of actions and stores to prevent unpredictable update loops.

The library coordinates asynchronous operations by managing event streams and triggering related success or failure actions. It also provides a global state registry that tracks store states via unique identifiers, enabling deep cloning for persistence and time-travel debugging.

Its capability surface covers centralized state management, including the creation of data stores and de
- [jacob-y/django-clean-architecture](https://awesome-repositories.com/repository/jacob-y-django-clean-architecture.md) (134 ⭐) — example of clean architecture with django
- [krasimir/react-in-patterns](https://awesome-repositories.com/repository/krasimir-react-in-patterns.md) (13,578 ⭐) — This project is a comprehensive guide to architectural patterns and design techniques for building modular user interfaces with React. It focuses on structuring component hierarchies, implementing state management patterns, and decoupling services to ensure applications remain maintainable and scalable.

The collection emphasizes strategies for dependency injection and the separation of business logic from presentation layers. It provides detailed approaches for utilizing containers, higher-order components, and module registries to isolate external services and third-party libraries from the
- [bufferapp/android-clean-architecture-boilerplate](https://awesome-repositories.com/repository/bufferapp-android-clean-architecture-boilerplate.md) (3,684 ⭐) — An android boilerplate project using clean architecture
- [patrickyin/clean-architecture-android-kotlin](https://awesome-repositories.com/repository/patrickyin-clean-architecture-android-kotlin.md) (327 ⭐) — Using Uncle Bob's clean architecture with Kotlin language and the latest Android technologies(Rx, Dagger2 etc.).
- [hecrj/iced](https://awesome-repositories.com/repository/hecrj-iced.md) (30,762 ⭐) — Iced is a cross-platform GUI library for Rust designed for building native desktop applications. It functions as a reactive toolkit that manages application state by mapping user interactions to messages, which then trigger automatic view refreshes.

The framework utilizes a rendering system that supports both hardware-accelerated GPU graphics and software backends to ensure compatibility across multiple operating systems. It implements a reactive model inspired by the Elm architecture to coordinate state updates and view reconciliation.

The toolkit includes a flexible layout engine and a mod
- [baidu/san](https://awesome-repositories.com/repository/baidu-san.md) (4,739 ⭐) — San is an isomorphic JavaScript framework and single-page application toolkit used for building user interfaces with reusable components. It functions as a reactive UI library that synchronizes application state with the interface through data binding and declarative templates.

The framework is distinguished by its support for both server-side HTML generation and client-side hydration to improve initial load performance and search engine optimization. It employs a specialized template-to-array compilation process to compress template structures and reduce network costs.

The project provides
- [coryhouse/react-slingshot](https://awesome-repositories.com/repository/coryhouse-react-slingshot.md) (9,646 ⭐) — react-slingshot is a JavaScript frontend boilerplate and starter kit designed to bootstrap React applications. It provides a pre-configured foundation that integrates React and Redux for state management, alongside routing and a unidirectional data flow.

The project features an integrated build pipeline that handles Babel transpilation, Sass compilation, and module bundling. It includes a development environment with hot module replacement and source maps for rapid iteration, as well as production optimization tools for minifying assets and analyzing bundle size.

The toolkit covers a broad s
- [panagiop/node.js-clean-architecture](https://awesome-repositories.com/repository/panagiop-node-js-clean-architecture.md) (1,159 ⭐) — A use case of Clean Architecture in Node.js comprising of Express.js, MongoDB and Redis as the main (but replaceable) infrastructure.
- [charmbracelet/bubbletea](https://awesome-repositories.com/repository/charmbracelet-bubbletea.md) (43,164 ⭐) — This framework provides a functional architecture for building interactive command-line applications. It utilizes a reactive runtime engine that synchronizes application state, user input, and visual output through a central event-driven message loop. By employing a unidirectional data flow pattern, the framework separates the definition of application state from the logic that processes updates and the declarative rendering process that transforms state into terminal-ready output.

The framework distinguishes itself through its approach to side-effect management and terminal environment adapt
- [flutter-team-archive/plugins](https://awesome-repositories.com/repository/flutter-team-archive-plugins.md) (17,710 ⭐) — This project is a collection of official plugin packages and a native integration library designed to provide a consistent interface for accessing hardware and software functionality across different mobile and desktop platforms. It serves as a native platform bridge, enabling cross-platform applications to invoke native code and manage operating system dependencies.

The project utilizes a federated plugin architecture, splitting plugins into common interfaces and separate platform implementations to allow for independent development and extension. It further supports native integration throu
- [reswift/reswift](https://awesome-repositories.com/repository/reswift-reswift.md) (7,594 ⭐) — ReSwift is a unidirectional data flow framework for Swift applications that centralizes state management within a single store. It ensures predictable and traceable updates by requiring all state modifications to occur through explicit actions processed by reducer functions.

The library includes a state time travel debugger that records and replays sequences of actions to reload or rewind the application state. It also provides an asynchronous action dispatcher to handle side effects and network requests while maintaining synchronized state updates.

The framework covers a broad surface of st
- [threedotslabs/wild-workouts-go-ddd-example](https://awesome-repositories.com/repository/threedotslabs-wild-workouts-go-ddd-example.md) (6,348 ⭐) — 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
- [vueuse/vueuse](https://awesome-repositories.com/repository/vueuse-vueuse.md) (22,092 ⭐) — This project is a comprehensive collection of modular, reactive functions designed to streamline the development of user interfaces. It serves as a toolkit for managing application state, wrapping native browser hardware and system features, and encapsulating common logic patterns into reusable units. By binding asynchronous data sources, browser events, and system properties to component state, it provides a unified framework for building interactive web and desktop applications.

The library distinguishes itself through its focus on composition and lifecycle management, allowing developers t
- [bxcodec/go-clean-arch](https://awesome-repositories.com/repository/bxcodec-go-clean-arch.md) (10,118 ⭐) — 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
- [vincentjouanne/nest-clean-architecture-ddd-example](https://awesome-repositories.com/repository/vincentjouanne-nest-clean-architecture-ddd-example.md) (739 ⭐) — 🏛️   Nest.js clean architecture example following some DDD principles with use-cases written in functionnal programming.
- [vuejs/core](https://awesome-repositories.com/repository/vuejs-core.md) (53,861 ⭐) — Vue is a progressive JavaScript framework designed for building modular, reactive user interfaces. It utilizes a component-based architecture that allows developers to encapsulate logic, templates, and styles into reusable units. At its core, the framework employs a virtual DOM renderer and a proxy-based reactivity system to synchronize application state with the document object model efficiently.

What distinguishes this framework is its focus on developer experience and flexibility. It supports a single-file component format that colocalizes related concerns, alongside a powerful composition
- [ardalis/cleanarchitecture](https://awesome-repositories.com/repository/ardalis-cleanarchitecture.md) (18,291 ⭐) — CleanArchitecture is a project template for ASP.NET Core designed to establish a standardized foundation for enterprise applications. It enforces architectural boundaries by separating core business logic from infrastructure and external dependencies, ensuring that the domain remains independent of technical concerns.

The project provides scaffolding that supports both multi-project solutions for complex systems and single-project vertical slices for simpler requirements. By organizing code around business entities and aggregates, it facilitates modular development where distinct parts of a s
- [jasontaylordev/cleanarchitecture](https://awesome-repositories.com/repository/jasontaylordev-cleanarchitecture.md) (19,657 ⭐) — 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
- [getify/functional-light-js](https://awesome-repositories.com/repository/getify-functional-light-js.md) (16,763 ⭐) — Functional-Light-JS is a JavaScript functional programming library designed to implement functional patterns within JavaScript applications. It serves as a toolkit for declarative data processing, immutable data management, and the construction of complex logic through higher-order functions.

The library focuses on a pragmatic implementation of functional programming, providing utilities for curried argument application and function composition. It emphasizes the use of pure functions to calculate state updates and manage application data without side effects.

The project covers broad capabi
- [mweststrate/use-immer](https://awesome-repositories.com/repository/mweststrate-use-immer.md) (4,536 ⭐) — use-immer is a React state management utility that provides a custom hook for updating immutable state. It allows for the modification of a temporary draft version of data to calculate the next state transition.

The tool simplifies the management of complex state by enabling direct mutations on a draft, which removes the need to manually copy nested objects or arrays using spread operators. This approach ensures the generation of a new immutable snapshot for predictable state changes.

The library covers capabilities for updating deeply nested state and supports processing state changes throu
- [flutter-webrtc/flutter-webrtc](https://awesome-repositories.com/repository/flutter-webrtc-flutter-webrtc.md) (4,468 ⭐) — This project is a WebRTC plugin for Flutter that provides a real-time communication framework for implementing peer-to-peer voice, video, and data streaming. It functions as a cross-platform media streamer and hardware media controller, allowing applications to manage device cameras and microphones across mobile, desktop, and web platforms.

The framework includes a dedicated peer-to-peer data channel interface for exchanging arbitrary data packets with low latency. It ensures privacy and data integrity through end-to-end encryption for all audio, video, and data transmissions.

Broad capabili
- [imsanjaysoni/noteapp-clean-architecture](https://awesome-repositories.com/repository/imsanjaysoni-noteapp-clean-architecture.md) (195 ⭐) — Live Web Demo 🚀
- [evancz/elm-architecture-tutorial](https://awesome-repositories.com/repository/evancz-elm-architecture-tutorial.md) (4,169 ⭐) — This project is an educational guide and tutorial for the Elm application architecture. It provides instruction on implementing functional state management and modular architectural patterns for user interfaces.

The tutorial focuses on the model view update pattern, utilizing a single source of truth for centralized state management. It demonstrates how to use discrete message types to trigger state transitions through pure update functions, ensuring a unidirectional data flow from view events back to the view.

The material covers declarative UI development, transforming application state in
- [gskinnerteam/flutter_vignettes](https://awesome-repositories.com/repository/gskinnerteam-flutter-vignettes.md) (4,750 ⭐) — This project is a collection of reference implementations and experimental user interface components. It serves as a gallery of examples demonstrating advanced animations, custom graphic rendering, and non-standard interaction techniques.

The repository provides showcases for high-fidelity motion, including 3D transformations, image sequence animations, and fluid page transitions. It includes a library of graphic experiments that use canvas drawing and vector paths to render particle systems and data visualizations.

The implementation surface covers a range of advanced UI capabilities, such
- [pvarentsov/typescript-clean-architecture](https://awesome-repositories.com/repository/pvarentsov-typescript-clean-architecture.md) (1,501 ⭐)
- [fingerprintjs/fingerprintjs](https://awesome-repositories.com/repository/fingerprintjs-fingerprintjs.md) (27,334 ⭐) — Fingerprint is a visitor identification and fraud detection platform that generates persistent, unique identifiers by analyzing browser and device attributes. By extracting technical signals from the client environment, it enables reliable user tracking across sessions without relying on traditional cookies.

The platform distinguishes itself through its focus on high-accuracy identification and security-first architecture. It employs edge-side proxying to bypass ad-blockers and privacy restrictions, ensuring consistent data collection. To maintain data integrity, it uses cryptographic payload