Projects sharing features with IOS Clean Architecture MVVM

Zend Framework is a comprehensive set of decoupled components for building modular, event-driven web applications. It implements an MVC architecture to separate business logic from the user interface and provides a structured request-handling system through a sequential middleware pipeline. The project features a factory-driven dependency injection container to automate object instantiation and manage class lifecycles. It also includes a comprehensive security suite for verifying user identities and restricting resource access using access control lists and role-based access control adapters.

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

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

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 backend framework built with TypeScript that implements clean architecture and SOLID principles to support scalable server-side development. It provides a structured environment for building applications that require secure user authentication, role-based access control, and interactive data collection workflows. The framework distinguishes itself by enforcing a strict separation of business logic from infrastructure concerns through a layered design and dependency injection. It utilizes a schema-first approach to expose application functionality simultaneously through REST

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 collection of reference implementations and code samples for building cross-platform user interfaces using the Xamarin.Forms framework. It provides practical examples for developing mobile and desktop applications from a single codebase targeting multiple operating systems. The repository focuses on architectural patterns and integration strategies, specifically demonstrating the use of MVVM to synchronize data between models and views. It includes samples for native platform integration, such as invoking platform-specific APIs and creating custom renderers to override defau

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

Draper is a presentation layer framework and decorator library for Ruby on Rails that implements the view-model pattern. It serves as a proxy-based system to separate presentation logic from business models, allowing view-specific data transformations to be isolated from the underlying data. The framework provides specialized capabilities for managing how data is displayed, including the ability to wrap single objects or entire collections. It supports recursive decoration for associated models and the injection of view context and request state into decorators to allow for conditional presen

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

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 clean architecture reference implementation and modular project template for Android development. It provides a structural blueprint designed to isolate business logic from external frameworks and user interfaces. The template emphasizes a modular approach to organize code into independent modules, which is intended to improve build times and long-term project scalability. It demonstrates the application of domain-driven design to keep core business rules and entities independent from the underlying platform. The implementation covers several key architectural patterns, inc

FastHub is a native Android mobile client designed for managing GitHub repositories, issues, and pull requests. It provides a visual interface for interacting with Git version control, acting as a repository manager for editing files, tracking project milestones, and handling account administration from a handheld device. The application supports multi-account authentication, allowing users to connect via tokens or passwords to access different user profiles and enterprise accounts. It distinguishes itself with offline repository browsing, utilizing local database caching to view project data

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

Clean React is a frontend development framework and application template designed to provide a structured foundation for building scalable web applications. It serves as a boilerplate that organizes complex user interface logic into decoupled, testable layers using TypeScript. The project distinguishes itself by enforcing a strict clean architecture and interface-driven design, which separates high-level business rules from low-level framework details. It integrates a dependency injection container and reactive state management primitives to ensure that system components remain interchangeabl

Infinity-For-Reddit is an open-source Android client and social content browser for Reddit. It functions as an API wrapper that allows users to browse and interact with Reddit communities on Android devices. The application covers Reddit account administration and community engagement, enabling users to vote on posts, save content, and submit text, images, or videos. It also provides tools for discussion management, allowing users to write, edit, and organize comment threads. The project includes capabilities for monitoring social activity through notifications and following users, as well a

Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments. The framework distinguishes itself through a unified approach to reactive and imperative program

This project is an Android SDK designed to integrate conversational voice interfaces into mobile applications. It utilizes a Model-View-ViewModel architecture to separate business logic from user interface components, providing a structured framework for managing complex voice interactions. The library features a modular pipeline that handles the entire flow of a conversation, including microphone input capture, speech transcription, intelligent response generation, and audio synthesis. A key differentiator is its ability to analyze acoustic features from audio input to detect user emotional

KMP-Awesome is a curated directory and resource index for the Kotlin Multiplatform ecosystem. It serves as a centralized hub for developers to discover libraries, frameworks, and tools designed to streamline the creation of shared codebases for mobile, desktop, and web applications. The project distinguishes itself by organizing a comprehensive collection of solutions that address the core challenges of cross-platform development. It highlights resources for implementing shared business logic, declarative user interface components, and type-safe data persistence layers. By providing a structu

CloudReader is an Android music client designed for streaming music and consuming cloud content. It is implemented as a Material Design application that provides a specialized interface for cloud music streaming and digital media browsing. The application features a cloud music streaming interface and a content browsing system for exploring articles, community forums, and question-and-answer sections. It includes utilities for content search, query history tracking, and the generation of desktop shortcuts for quick access to specific application sections. The system supports visual customiza

This project is a shared technical specification and standard interface for dependency injection containers in PHP. It defines a common set of interfaces for retrieving services and dependencies, ensuring that different container implementations remain interoperable across the PHP ecosystem. By establishing a standardized API for dependency retrieval, the project allows developers to create libraries that function with any compliant container. This prevents vendor lock-in and enables different container implementations to be swapped without requiring changes to the application code. The spec

tiny-spring is a Java inversion of control container and aspect-oriented programming framework. It provides a system for managing object lifecycles and dependency injection to decouple application components. The project features a bytecode proxy generator that enables method interception and behavioral modification for classes that do not implement interfaces. It uses pointcut expressions to match specific classes and methods for the execution of cross-cutting logic via dynamic proxies. The framework manages singleton components and resolves object dependencies using lazy initialization. Ap

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

Knockout is a client-side UI library and JavaScript framework used to create responsive web interfaces. It functions as a declarative data binding library and an observable data model system that decouples business logic from the document object model. The project implements the Model-View-ViewModel pattern to separate application logic from the user interface. It synchronizes data models with visual views by linking internal JavaScript properties to HTML elements, allowing the interface to update automatically when underlying data changes. The framework provides capabilities for dynamic fro

Awilix is a JavaScript dependency injection framework and inversion of control container. It provides a centralized system for registering and resolving services, decoupling application components by automating how dependencies are created and passed to the functions or classes that require them. The framework features an automatic module loader that scans the filesystem using glob patterns to register dependencies based on filenames and exports. It supports parameter-name-based injection and proxy-based resolution to manage how dependencies are delivered to constructors and functions. The s

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

Inject is a dependency injection framework for Go that automates the assembly of complex object graphs. By leveraging runtime reflection, the library dynamically inspects object structures to resolve and populate required dependencies, decoupling component initialization from business logic. The framework manages object lifecycles through both singleton and factory-based provisioning. It maintains a central registry to share singletons across an application for consistent state, while also supporting the creation of unique, private instances to isolate state between different components. To