Open-source alternatives to Study

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

This project is a cross-platform mobile app template and UI starter for Android and iOS. It provides a foundation for building consistent mobile interfaces from a single declarative codebase. The architecture implements a reactive state management framework using BLoC and RxDart to decouple business logic from the user interface. It also includes an internationalized mobile architecture to manage multi-language support and regional localization across the application. The codebase covers capabilities for mobile client implementation, including the rendering of remote content, local data pers

Effector is a reactive state management library designed for building complex, event-driven applications. It functions as a data flow engine that models application logic as a directed acyclic graph, ensuring that state updates propagate automatically through interconnected nodes. By utilizing atomic state updates and declarative unit composition, the library maintains data consistency and provides a predictable execution model for managing application state. The project distinguishes itself through its framework-agnostic architecture, which decouples business logic from user interface implem

This project is an open-source Flutter GitHub client and cross-platform mobile application. It serves as a GitHub GraphQL client and OAuth mobile app, providing a mobile interface for browsing repositories, issues, and user profiles. It is also designed as an open-source architecture reference to demonstrate Flutter best practices, state management, and multi-language localization. The application distinguishes itself by using GraphQL queries to retrieve nested repository and user information, reducing network requests and over-fetching. It utilizes a shared Dart codebase to provide a consist

This project is a technical reference and study of the Go language internals, providing a deep dive into the runtime architecture, compiler internals, and memory management mechanisms. It serves as a guide for analyzing how the Go compiler and runtime implement low-level features. The materials specifically detail the implementation of polymorphism through virtual tables and dynamic dispatch. It covers the translation of high-level source code into portable pseudo-assembly and machine-specific instructions, alongside the structural mechanics of the interface system, including scalar type boxi

BeeHive is a modular architecture framework for iOS applications. It provides a dependency injection container, an event bus middleware, a module lifecycle manager, and a service locator to organize an application into independent functional modules. The framework distinguishes itself by utilizing asynchronous module loading to reduce application startup time and prevent main thread blocking. It employs macro-driven automatic module registration to decouple instantiation from application logic and uses protocol-based service mapping to resolve dependencies without requiring direct imports. T

Swift System is a low-level library that provides safe, idiomatic abstractions for operating system calls and file path manipulation. It serves as a programming interface wrapping native operating system calls and platform types for reliable desktop and mobile integration. The library enforces strict separation of incompatible string types at compile time by wrapping raw values in domain-specific structures, preventing the mixing of system paths with arbitrary text. It translates raw numeric operating system error codes into strongly typed enumeration cases and manages system handles and file

This project is a comprehensive learning resource and technical reference for reactive programming with RxJS. It provides a structured curriculum, curated examples, and an indexed operator catalog to help developers shift from imperative to declarative programming using observable data streams and functional operators. The repository features a library of reactive UI patterns and implementation recipes. These cover practical applications such as type-ahead search, game loops, gesture-based interactions like swipe-to-refresh, and security overlays like lockscreens. The resource covers a broad

This project provides a set of development guidelines and architectural recommendations for building iOS applications. It focuses on structuring Swift applications to decouple business logic from the user interface to improve testability and maintenance. The project covers specific implementation standards for security, such as using keychain storage for sensitive data and TLS certificate pinning for network traffic. It also defines patterns for code quality enforcement through static analysis and compiler configurations, as well as strategies for asset and localization management. The guide

Shiny is a framework for building interactive web applications using R code, eliminating the need for HTML, CSS, or JavaScript. At its core, it provides a reactive programming model that automatically tracks data dependencies and re-executes only the parts of an application that depend on changed inputs. The framework handles server-side UI rendering and maintains persistent WebSocket connections between the browser and server for real-time updates without page reloads. The framework distinguishes itself through deep integration with the R ecosystem, including the ability to embed interactive

This project serves as a comprehensive educational roadmap and curriculum for mastering professional Android application development. It provides a structured learning path that guides developers through the essential system design principles, architectural patterns, and technical skills required to build, test, and deploy scalable mobile software. The resource distinguishes itself by organizing complex technical topics into a logical sequence, covering everything from foundational mobile development tooling to advanced software engineering practices. It emphasizes industry-standard patterns

rinf is a cross-platform native bridge and integration layer used to connect business logic written in Rust to application frontends. It functions as a cross-language message broker and binary serialization framework that enables the exchange of structured data between a Rust backend and user interfaces across mobile, desktop, and web targets. The project utilizes a schema-driven code generator to produce language-specific message classes from shared definitions. This ensures type-safe message passing and consistency across different programming environments, preventing data mismatches during

This repository serves as a technical learning platform and study guide focused on low-level system design and distributed systems architecture. It provides educational materials and implementation examples designed to help engineers master the foundational components required to build scalable and reliable backend infrastructure. The project emphasizes the practical application of architectural patterns through the construction of essential software modules. By implementing building blocks such as in-memory caches, event-driven message buses, and rate limiters, users can analyze the internal

The Reactive Extensions for JavaScript

This project is a technical reference and a collection of internal analysis notes focused on the Go language runtime and compiler. It provides a detailed breakdown of the language internals, covering memory management, garbage collection, and the execution model of the scheduler. The material distinguishes itself by providing deep dives into low-level system details, including a reference for Go assembly instructions, register usage, and system call interfacing. It specifically analyzes the internal implementation of concurrency primitives, such as the goroutine scheduling mechanism, channel

This project is a comprehensive framework for iOS application development, centered on building mobile applications that feature custom user interface components, asynchronous task management, and local data persistence. It serves as a technical knowledge base for software engineering, providing tools to organize and publish architectural analyses and notes in Markdown format. The framework distinguishes itself through a robust document-based storage layer that utilizes BSON-formatted records to perform CRUD operations within a NoSQL document store. It provides extensive system integration ca

This repository provides a comprehensive collection of functional code samples designed to demonstrate modern development patterns and architectural practices for the Android platform using Kotlin. It serves as a practical guide for implementing standard design patterns that decouple business logic from user interface components, ensuring that applications remain maintainable and testable. The project distinguishes itself by offering isolated, hands-on implementations of complex mobile programming tasks. It covers a wide range of capabilities, including asynchronous networking, local database

UniRx is a reactive programming library and event orchestration framework for the Unity engine. It implements observable sequences and functional operators to transform callbacks, coroutines, and engine events into cancellable data streams for unified asynchronous event handling. The library provides a reactive UI binding system that synchronizes data models with user interface elements to trigger automatic visual updates. It includes a type-based publication and subscription system to route messages between producers and consumers, decoupling internal game components. The framework covers a

Universal API for request permission and get its statuses.

Armeria is a Netty-based microservice framework used for building high-performance asynchronous services. It functions as a multi-protocol RPC server capable of exposing gRPC, Thrift, and REST services on a single unified port. The project is distinguished by its ability to run diverse communication protocols simultaneously and its integrated RPC debugging web console, which allows for the discovery and invocation of remote procedure calls via JSON. It also includes a gRPC to JSON transcoder to enable web client compatibility with Protobuf services. The framework provides a comprehensive sui

This project is a set of coding standards, architectural patterns, and type safety guidelines for writing Swift source code. It provides a framework for maintaining clean and maintainable code through established conventions and formatting rules. The guide prioritizes composition over class inheritance by favoring value types and final classes. It establishes a policy for access control to manage boundaries between internal logic and external components through explicit visibility modifiers. The standards cover type safety optimization through immutable bindings and safe optional handling. A

This project is a curated collection of technical questions and answers designed to assist developers in preparing for software engineering interviews within the iOS ecosystem. It serves as a structured study tool for evaluating proficiency in mobile application architecture, system design, and core programming concepts. The repository provides a comprehensive reference for essential development topics, including memory management, concurrency, design patterns, and data persistence. By covering these foundational areas, it enables users to review common industry interview subjects and test th

SwiftTips is a curated collection of guides, libraries, and design patterns focused on Swift language mastery, application architecture, and API design. It provides a technical resource for implementing advanced coding techniques and architectural best practices. The project emphasizes creating type-safe and conversational interfaces through strategic protocol composition and generics. It offers specialized patterns for building modular UI systems and managing complex view hierarchies, alongside comprehensive strategies for unit testing and dependency injection. The resource covers a broad s

This project is a reference implementation of the Model-View-Presenter (MVP) architecture for Android applications. It focuses on separating business logic from the user interface by decoupling data logic, UI presentation, and view layers. The implementation distinguishes itself through the inclusion of a boilerplate generator that automatically creates the activity, presenter, and view files required for the MVP pattern. It utilizes a compile-time dependency injection framework to manage object lifetimes and a reactive programming workflow to handle asynchronous data streams and event propag

RxDocs is a community-driven project that provides comprehensive technical documentation and educational resources for reactive programming. It serves as a centralized reference for developers implementing asynchronous data streams, offering detailed guides and operator specifications to support the management of complex event sequences. The project distinguishes itself by providing localized Chinese translations of technical concepts, ensuring that developers can access accurate information in their preferred language. It also focuses on accessibility by packaging these materials into portab

Swinject is a dependency injection framework for Swift that manages object creation and wiring through a centralized container. It resolves dependencies by looking up registered service types at runtime, supporting iOS, macOS, and Linux platforms. The framework provides multiple injection patterns, including initializer injection where dependencies are passed through initializer parameters, property injection that sets resolved dependencies on stored properties after object creation, and method injection that calls methods with resolved dependencies as arguments. It handles complex dependency

This repository is a collection of practical code snippets and implementation patterns for Flutter and Dart. It serves as a comprehensive guide and reference for asynchronous programming, state management patterns, and UI component design. The project provides advanced language reference material covering generics, reflection, factory constructors, and null-aware operators. It also includes specific utilities for manipulating Dart collections, such as helper methods for transforming and filtering maps, lists, and iterables. The coverage extends to high-level capabilities including asynchrono