Open-source alternatives to React Projects

React is a JavaScript library for building user interfaces based on a component-driven architecture and unidirectional data flow.

This project is an educational course and a collection of frontend projects designed to teach the core concepts and architecture of the React library. It serves as a practical guide for building modular user interfaces through a series of hands-on project builds. The repository includes a technical implementation of a custom React renderer, demonstrating how to transform JSX elements into a document object model. It further provides examples of state management, specifically illustrating how to share global data across a component tree using the provider pattern to avoid property drilling. T

This project is a collection of practical code samples and demonstrations for building user interfaces with React. It serves as a set of examples illustrating common interface patterns, state management techniques, and the implementation of modular, reusable components. The repository provides specific demonstrations for several core development areas. These include samples for retrieving and rendering asynchronous data from external APIs, managing component lifecycles during mounting and unmounting, and handling internal state to sync form inputs. It also includes guides for direct document

Preact is a lightweight declarative user interface library designed for building high-performance web applications. It utilizes a component-based architecture where interfaces are defined as functional or class-based units, relying on a virtual DOM to perform efficient state reconciliation and updates. By prioritizing a minimal footprint, the library enables developers to create modular, predictable, and testable user interfaces while maintaining compatibility with standard browser APIs. The library distinguishes itself through a reactive state engine that leverages signals to track dependenc

react-pxq is a React Redux boilerplate and state-driven UI framework designed for building single-page applications. It functions as a starter project template that combines a client-side routing system with global state management to synchronize data across a component hierarchy. The project implements a code-split web application architecture that uses lazy loading to reduce initial bundle sizes. It integrates a navigation system that maps URL paths to components without triggering full page reloads. The framework covers centralized state management through a global store and action-based

Frontend Workshop from HTML/CSS/JS to TypeScript/React/Redux

This repository is a collection of learning resources, instructional materials, and practical reference implementations for the React library. It provides code snapshots, application boilerplates, and a repository of examples designed to support a structured curriculum for building React applications. The project offers specific implementation guides and samples for managing application state, mapping routes with shared layouts, and creating validated form systems. It includes versioned code snapshots, completed exercise references, and presentation materials to help users validate their prog

re-frame is a functional framework for building single-page applications in ClojureScript. It provides a centralized, immutable database that serves as the single source of truth for the entire application state, enforcing a strict unidirectional data flow where events trigger state transitions and subsequent view updates. The framework distinguishes itself through a reactive signal graph and an interceptor-based middleware pipeline. By treating application logic as a sequence of data-driven events and declarative side effects, it decouples business logic from the view layer. This architectur

Ember.js is a structured JavaScript web framework designed for building scalable web applications. It utilizes a Model-View-Controller architectural pattern and incorporates a component-based UI library, a dependency injection framework, and a client-side routing engine. The framework distinguishes itself through a centralized registry for passing shared services across components and routes, alongside a routing system that maps URLs directly to templates and data models to manage navigation. Its broader capabilities include reactive state synchronization and computation memoization for UI p

React is a JavaScript library for building user interfaces through the composition of modular, self-contained components. It employs a declarative programming model where developers describe the desired visual state, and the library automatically manages the underlying document updates and state synchronization. By utilizing a virtual representation of the document, it calculates and applies minimal changes to the browser, ensuring efficient rendering even in complex applications. The library distinguishes itself through a sophisticated scheduling system that manages rendering work in increme

This project is a TypeScript React starter template and frontend development boilerplate. It provides a pre-configured project scaffold and foundation for building type-safe user interfaces, integrating essential tooling for typing, linting, and testing to accelerate the start of a web application. The scaffold distinguishes itself by providing a complete production asset pipeline that generates minified JavaScript and CSS bundles to optimize loading speeds. It includes a dedicated component testing suite for executing logic and snapshot tests in a simulated browser environment, alongside a h

This project is a learning course and instructional resource for React frontend development. It consists of a structured curriculum, architectural guides, and a library of reference materials designed to teach the construction of user interfaces and web applications. The repository provides a collection of project implementations, including e-commerce stores and CRUD applications, to serve as reference architectures. It includes curated lessons and code examples that focus on implementing state management and type safety patterns. The materials cover frontend architecture patterns, the integ

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

Vugu is a Go WebAssembly UI library and framework used to build type-safe, component-based single-page applications. It functions as a single-file component framework that bundles markup, styles, and logic into modular units, utilizing a virtual DOM engine to synchronize state changes with the browser output. The project features a Go component generator that converts custom UI templates into executable Go source code at compile time. It distinguishes itself through a WebAssembly-based runtime that executes application logic as a compiled binary in the browser and a server-side rendering tool

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 comprehensive educational curriculum and resource for full-stack web development. It provides a structured collection of source code, implementation guides, and practical exercises designed to teach core front-end and back-end programming principles, including database connectivity and interface design. The repository serves as a practical guide for building integrated web applications using modern JavaScript frameworks. It demonstrates essential development patterns such as component-based user interface composition, reactive state management, and asynchronous data fetching

Recoil is an atomic state management framework and library for React. It functions as a state container that breaks application data into independent units called atoms to minimize unnecessary component re-renders. The system integrates with React hooks to provide a reactive state store. It utilizes a graph-based approach to data flow, employing a dependency graph to track relationships between state units and propagate updates automatically. The library coordinates global state across complex component trees, enabling independent components to communicate and share data without manual prop

ComponentKit is a declarative UI framework for building iOS interfaces through composition of small, reusable components. It provides a structured approach to constructing user interfaces where each component is defined as an immutable, pure function of its inputs, enabling predictable rendering and state management. The framework supports both stateless and stateful components, with controllers that can be attached to manage persistent state across component updates. The framework distinguishes itself through its component architecture that emphasizes explicit data flow and compile-time safe

Om is a frontend state management library and reactive user interface framework that integrates ClojureScript functional programming with the React virtual DOM rendering engine. It provides a bridge to build responsive web interfaces where visual elements automatically update when underlying application data changes. The project centers on a normalized state store that flattens complex data structures into a relational format. This data is accessed through a reader-based querying system, which decouples the user interface from the state by allowing components to declare specific data requirem

Opentui is a terminal user interface framework for building interactive command line applications. It provides a component-based system featuring a flexbox layout engine, a virtual node component tree, and a low-level 2D cell array renderer. The project is distinguished by a sophisticated keyboard binding engine that maps complex multi-stroke sequences and chords to named commands using prioritized, reactive layers. It also implements a plugin architecture that allows external modules to inject custom UI components into designated layout slots and extend input logic at runtime. Its capabilit

This project is a pre-configured foundation for web applications, providing a structured codebase and build tools for starting new frontend projects. It serves as a boilerplate that integrates React for the user interface, Redux for state management, and React-Router for navigation. The architecture is distinguished by its use of nested route definitions to handle hierarchical navigation and a system for dynamic reducer injection, which allows state management logic to be added to the store at runtime as specific modules load. The toolkit covers a broad range of frontend capabilities, includ

go-app is a WebAssembly frontend framework and UI library for building progressive web apps using the Go programming language. It enables the execution of Go code directly in the browser to manage application logic and client-side views. The framework provides a component-based system for creating reusable interface elements with declarative syntax and automatic state synchronization. It includes a client-side router that maps URL paths to specific interface components to enable navigation within a single-page application. The project covers general frontend development capabilities, includi

Semi Design is a React UI component library and design token system used to build web application frontends. It provides a collection of pre-built interface elements and a framework of visual constants to maintain consistent branding across a product. The project features a design-to-code workflow that converts visual design drafts into production-ready React code and stylesheets. It includes an internationalization framework for adapting interfaces to different languages and text layouts, as well as a web component wrapper to isolate UI elements for use in SDKs and browser plugins. The libr

This library is a browser history API wrapper and client-side routing state manager. It provides a programmatic interface for managing the browser session history stack and synchronizing application state changes with the URL. The project functions as a JavaScript session history manager that enables custom navigation and routing control. It handles the synchronization of client-side routing state to ensure consistent back and forward movements within the browser. The system covers broader capabilities including browser session history management and general JavaScript navigation control.

This project is a structured architectural layer for Backbone.js that implements the model-view-controller pattern for building complex single-page applications. It serves as a view management library and application framework that organizes views and data into manageable components and regions. The framework provides a centralized event aggregator pattern to coordinate communication between decoupled application modules without direct dependencies. It also includes a configuration-based client-side routing engine that maps browser URLs to specific controller actions. The system covers front

Choo is a minimalist frontend framework providing a tiny foundation for building web applications. It functions as an event-driven application core that decouples business logic from rendering and includes a client-side router to manage browser history and URL mapping without page reloads. The project distinguishes itself through an architecture that combines a server-side rendering engine for generating static HTML strings with a stateful UI component library. This allows for the creation of self-contained interface elements that maintain internal data and persist across global renders. The

Lit is a library for building lightweight, interoperable web components. It provides a base class that leverages native browser APIs to encapsulate state, logic, and styles, allowing developers to create custom elements that function consistently across any modern web project. The framework distinguishes itself through a reactive property system that automatically triggers efficient, batched DOM updates. By utilizing tagged template literals, it defines declarative UI structures that are compiled into optimized update instructions. Its architecture emphasizes modularity through a reactive con