Open-source alternatives to Ios Oss

This project is an automated testing framework designed to capture and verify the visual state of Android interface components. It provides a system for generating deterministic snapshots of UI elements, allowing developers to establish baselines for layout consistency and detect unintended visual regressions across different software versions and hardware configurations. The framework distinguishes itself by enabling isolated component rendering, which allows individual views to be tested without requiring a full application build. It ensures consistency by controlling the rendering lifecycl

mobx-react is a library that provides state bindings to connect React components to MobX observable state. It functions as a component state synchronizer, ensuring that user interface elements automatically re-render only when the specific observed data they consume changes. The project enables a decoupled state architecture by moving business logic and domain state into standalone stores, separating data management from the React component tree. It facilitates global state distribution across deep component hierarchies using providers and context to avoid manual prop drilling. The library c

Arrow-js is a reactive UI framework and server-side rendering system designed for building agentic interfaces. It functions as a reactive state manager and isomorphic routing engine, enabling the creation of web applications that utilize tagged template literals for efficient DOM updates. The project distinguishes itself by incorporating a WebAssembly code sandbox, which allows untrusted or AI-generated code to execute within a secure virtual machine to render interfaces without accessing the host DOM. It further enables agentic UI development by allowing AI agents to dynamically generate vie

MobX is a reactive state management library and fine-grained reactivity engine. It provides an observable data store that automatically triggers updates in the user interface when data structures change, functioning as a transparent functional reactive store to maintain a consistent source of truth. The system utilizes a dependency-graph mapping and proxy-based object observation to track data dependencies. This ensures that only the specific components dependent on changed data are updated, which reduces unnecessary re-renders and optimizes frontend performance. The library supports decoupl

Signals is a reactive state management library and fine-grained reactivity engine. It functions as a dependency-tracking state manager that maps relationships between values to ensure derived data and user interface elements remain synchronized. The library distinguishes itself through direct-to-node DOM binding, which allows state to update specific text nodes in the browser without triggering a full component render cycle. It employs a runtime dependency graph and atomic batching to group multiple state modifications into single notification cycles, reducing redundant executions. The syste

This project is an iOS snapshot testing framework designed to verify the visual consistency of user interface components. It functions as a utility for automated regression testing, ensuring that interface layouts and styling remain stable by comparing rendered view snapshots against pre-recorded reference images. The framework integrates directly with the native testing environment to automate the validation process during the build cycle. By capturing the visual state of a view hierarchy and performing a pixel-level comparison against stored ground truth images, it identifies unintended cha

This is the open-source Android application for Kickstarter, a crowdfunding platform that connects creators with backers. The app enables users to discover creative projects and campaigns, pledge financial support in exchange for tiered rewards, and share campaign details through social media and messaging platforms. The application is built with a standard Android architecture that combines compile-time dependency injection, reactive data flows, and declarative UI binding. It uses Dagger 2 for wiring together services and repositories, RxJava for managing asynchronous operations, and a Model

Solid is a declarative JavaScript framework for building user interfaces through fine-grained reactivity. By utilizing a compile-time template transformation process, it converts JSX into direct DOM manipulation instructions, eliminating the need for a virtual tree. This architecture allows the framework to track dependencies at the individual element level, ensuring that state changes trigger surgical updates to the interface. The framework distinguishes itself through its isomorphic rendering pipeline, which shares reactive logic across server and client environments to support both initial

Ripple is a full-stack TypeScript web framework and reactive UI library used for building interfaces with server-side rendering. It organizes user interfaces into a hierarchy of reusable, scoped components with built-in state management and client-side hydration. The framework is distinguished by its fine-grained reactivity, which updates specific DOM elements without requiring full component re-renders. It integrates server-side logic and client-side components within a single TypeScript codebase, enabling a unified full-stack development workflow. The system covers a broad range of capabil

Leptos is a full-stack Rust web framework designed for building reactive applications that share logic and types between the server and the browser. It provides a comprehensive toolkit for developing web interfaces where specific DOM nodes update automatically in response to changes in underlying reactive signals, rather than re-rendering entire component trees. The framework distinguishes itself through a fine-grained reactivity model that tracks dependencies at the individual data point level. It utilizes compile-time template transformation to convert declarative HTML-like syntax into opti

This project is a declarative framework for building reactive user interfaces by embedding logic directly into HTML markup. It functions as a lightweight state container that tracks data changes and automatically synchronizes the document object model with the underlying application state. By utilizing proxy-based observation, it ensures that interface updates occur precisely when reactive properties are modified. The framework distinguishes itself by allowing developers to define interactive behavior through custom attributes rather than external scripts. This approach enables the compositio

jscamp is a full-stack web development and education project focused on mastering JavaScript, TypeScript, and AI integration. It provides a structured curriculum and interactive exercises covering language fundamentals, frontend engineering, and backend API development. The project distinguishes itself through the implementation of autonomous AI agents capable of complex task automation, such as modifying files, managing servers, and executing API calls. It includes advanced AI development tools for conversational querying, real-time code suggestions, and automated repository analysis to gene

MPX is a cross-platform framework designed to build applications for multiple mini-program ecosystems and the web from a single codebase. It utilizes a static transpilation pipeline to transform source code into platform-specific bundles, employing a single-file component system that encapsulates templates, logic, and styles. The framework provides a reactive state management system that automatically synchronizes application data with the user interface through computed properties and watchers. The project distinguishes itself through a robust build-time toolchain that supports sub-package p

Riverpod is a reactive state management framework for Dart that manages application state through providers which automatically track dependencies and rebuild dependents when values change. It functions as an asynchronous data caching library, caching results of async operations and exposing loading, error, and data states to widgets without manual future handling. The framework includes a provider composition system that combines multiple providers into derived values that recompute automatically when any dependency changes, along with code generation for state providers that reduces boilerpl

jest-image-snapshot is a Node.js image testing library and visual comparison engine designed for visual regression testing within Jest. It provides a custom matcher to compare current images against baseline snapshots to identify pixel differences. The tool generates image diffs that highlight specific divergences between baseline and received snapshots. It includes mechanisms to update baseline images when changes are approved and allows for sensitivity tuning via pixel count, percentage thresholds, or blur to ignore noise. The library covers image snapshot management, including custom stor

Legend-State is a reactive state management library for JavaScript applications that provides a centralized container for application data. It utilizes a fine-grained reactivity engine to track state access automatically, allowing developers to update and retrieve data without the need for boilerplate patterns like reducers, actions, or dispatchers. The library distinguishes itself through its hierarchical, path-based state addressing and proxy-based dependency tracking. By isolating state dependencies, it ensures that user interface updates are triggered only for the specific components that

This project is a comprehensive guide to software architecture, providing a framework for designing maintainable, readable, and modular codebases. It focuses on establishing design best practices that help developers structure complex applications into independent, single-purpose units. The guide emphasizes the use of modular programming principles to decouple software components, allowing for greater reusability across different parts of an application or separate projects. By prioritizing interface-based design and the dependency inversion principle, it enables safe, incremental refactoring

Moon is a minimal reactive UI library for building user interfaces with a component composition framework, client-side routing, server-side rendering, and signals-based reactivity. It provides a virtual DOM diffing engine that computes minimal real DOM mutations, enabling efficient view updates by comparing in-memory UI representations against previous versions. The library distinguishes itself through a signals-based reactivity system that tracks data dependencies through observable signals, triggering targeted DOM updates only when values change. It implements a state driver pattern for uni

Vue-easytable is a high-performance data grid component designed for the Vue.js framework. It provides a comprehensive interface for displaying and managing large-scale tabular data, utilizing virtual scrolling to maintain responsiveness by rendering only the visible subset of rows within the browser. The component offers spreadsheet-style interaction, enabling users to perform direct, in-place data editing and manipulation. It supports complex grid configurations, including column pinning, row expansion, and data filtering, allowing for the organization of structured information to improve r

Cycle.js is a functional reactive web framework and observable-driven UI library used for building web applications. It employs a reactive stream architecture that treats the document object model and side effects as continuous data streams, coordinating state and logic through a functional cycle. The framework distinguishes itself by isolating side effects from core logic using a system of drivers. This architecture maps external events to internal commands through a symmetric input-output pipeline, ensuring that the application remains a cycle of pure functions. The project provides capabi

This is a snapshot testing framework for Swift that records and compares reference images or data representations to detect regressions in application state. It functions as a visual regression testing tool and a data snapshotting library, converting complex types into stable formats to verify internal state and object properties. The framework utilizes a multi-format snapshot strategy, allowing values to be represented as images, strings, or data blobs. It includes a mechanism for defining custom snapshot strategies to convert specific data types into comparable formats based on custom logic

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

language-ext is a functional programming framework for C# that provides a suite of immutable data structures and monadic types. It enables the implementation of pure functional programming patterns, utilizing containers to manage side effects, optional values, and error handling. The library is distinguished by its advanced concurrency and state management tools, including a software transactional memory system and lock-free atomic references. It also provides specialized utilities for distributed systems, such as vector clocks for causality tracking and deterministic data conflict resolution

Metro UI is a progressive front-end framework for building reactive single-page applications with a Metro-style design language. It provides a component-based UI library with over 150 prebuilt interface elements, a reactive state model that automatically updates the DOM when application data changes, and a responsive grid layout system for mobile-first web development. The framework uses an HTML-first approach where interactive interfaces are assembled by adding custom HTML attributes to elements, eliminating the need for manual JavaScript glue code. It includes a hash-based SPA router for na

react-basic provides a conceptual implementation of the React model, focusing on a component-based UI architecture. It employs pure functions to transform raw data into structural interface representations and uses a declarative system for managing UI state and hierarchical data distribution. The project distinguishes itself through specialized caching strategies, including tree-based result caching that stores values based on the structural position of elements. It also features a mechanism for deferred function execution to remove boilerplate from business paths and supports the isolation o

Vue Table with Tree Grid is a table component for Vue applications that displays hierarchical tree grids with expandable rows, custom cell formatting, and row interaction events. It transforms complex parent-child datasets into expandable tree grid structures with adjustable child indentation levels to help users explore multi-level information. The component supports reactive state-driven selection to maintain row expansion and checkbox selection states, alongside recursive tree-grid flattening that simplifies rendering calculations. It utilizes slot-based rendering to inject user-defined te

This is a Swift state management framework and application logic library designed for building applications with a single source of truth and unidirectional data flow. It provides a Redux-inspired architecture that separates business logic from side effects and user interfaces to ensure predictable application behavior across multiple screens. The framework focuses on modularity by allowing complex features to be decomposed into smaller, isolated components. This enables the development of UI-independent business logic that can be extracted into separate modules to improve compilation speed a