Projects sharing features with Redux Persist Store

Redux-Saga is a middleware library for Redux applications that manages asynchronous data flows and complex side effects. It serves as a decoupled state management effect layer and workflow orchestrator, utilizing JavaScript generator functions to pause and resume asynchronous operations without blocking the application. The library distinguishes itself by using generators to manage sequential or parallel tasks and state transitions outside of the main user interface thread. This approach allows for the coordination of complex asynchronous workflows, such as multi-step data fetching and API ca

Little State Machine is a lightweight state management library for React applications that provides a centralized data store for managing shared application information. It utilizes a context-based provider pattern to distribute state across the component tree, ensuring consistent data access without the need for manual property drilling. The library distinguishes itself through built-in support for automatic browser storage persistence, which synchronizes the in-memory state with local or session storage to maintain data continuity across page refreshes. It also incorporates middleware-drive

Easy-peasy is a React state management library and typed framework that provides a centralized store for managing global application state. It functions as an immutable state store and an async state orchestrator, ensuring end-to-end type safety for state definitions, actions, and derived values. The library distinguishes itself by converting direct mutation syntax into immutable updates to simplify the management of nested data. It includes a mechanism for persisting the state tree to storage and rehydrating it during the application boot process, with the ability to suspend the user interfa

This project serves as a comprehensive educational repository and technical reference collection, documenting a wide range of software engineering practices and modern development technologies. It provides a structured learning path for developers, curating tutorials and practical examples that cover the full lifecycle of application development, from initial project scaffolding to deployment and maintenance. The repository distinguishes itself by offering deep technical insights into complex architectural patterns, including actor-based concurrency models for managing parallel tasks and cont

Icepick is an Android instance state library and persistence tool designed to automate the serialization and restoration of object state within Android bundles. It provides a framework for maintaining application state during activity recreation, configuration changes, and process death. The project utilizes annotation-driven code generation to create the boilerplate logic required for bundle manipulation and key management. It distinguishes itself through a provider-based serialization system that allows for custom serialization and deserialization logic when handling complex types that do n

Effector is a reactive state management library and data flow orchestrator designed for building complex, event-driven applications. It models application logic as a directed acyclic graph, where state updates and asynchronous side effects propagate automatically through declarative pipelines. By decoupling business logic from user interface layers, it allows developers to maintain state in independent containers that communicate via standard interfaces, ensuring the system remains framework-agnostic. The library distinguishes itself through its robust support for isolated execution scopes, w

This is a Dart state management library and architectural framework that decouples business logic from the user interface by transforming a stream of events into a stream of states. It implements a business logic component pattern to ensure that state transitions are predictable and testable. The project distinguishes itself through advanced event stream processing, providing concurrency strategies to drop, restart, or queue incoming events. It includes a dedicated state persistence layer for saving and restoring application state to maintain session continuity, as well as tools for state his

Build Offline-First Apps for Web and React Native

This project is a client-side software development kit for iOS and macOS applications that integrates mobile software with a cloud-based backend. It functions as a mobile backend as a service interface, enabling developers to manage user authentication, cloud data persistence, and synchronization without the need to maintain server-side infrastructure. The framework is designed for offline-first development, utilizing a local datastore to cache application state and ensure functionality during periods of network disconnection. It features an automated synchronization engine that queues pendin

Pepperoni App Kit is a starter kit and project template for building cross-platform mobile applications for iOS and Android using React Native. It provides a pre-configured scaffold that establishes a modular architecture and shared codebase to bootstrap new projects. The kit integrates a predictable state management system with disk persistence for offline access and a controlled loop for coordinating asynchronous side effects and API interactions. It also includes built-in mechanisms for token-based session authentication and identity validation to maintain secure user logins. The project

This project is a web-based user interface for interacting with large language models, featuring streaming responses and persistent conversation history. It functions as an orchestration gateway that directs user prompts to specific language models and acts as a Model Context Protocol client to execute external tools and incorporate live data into conversations. The application includes a routing layer that analyzes input signals and tool requirements to dynamically direct messages to the most appropriate specialized model. It also provides customization settings for brand identity, allowing

Electric is a Postgres data synchronization engine and replication proxy designed to enable local-first software. It replicates data from Postgres databases to client-side stores in real time using logical replication, allowing applications to maintain a local embedded database for offline access and low-latency updates. The system distinguishes itself by using shapes to filter and authorize specific subsets of database rows and columns before streaming them to clients or edge workers. It further supports multi-user collaboration by integrating a conflict-free replicated data type framework t

The reverse-linear-sync-engine is a data synchronization framework designed to manage distributed application state. It provides a system for tracking local data mutations, resolving discrepancies between multiple sources, and maintaining consistency across connected clients through a centralized transaction-based model. The engine distinguishes itself by integrating reactive state observation with a transaction history stack. This combination allows the framework to automatically refresh interface components when data changes while simultaneously enabling precise undo and redo functionality.

bbolt is an ACID-compliant embedded key-value store for Go applications. It persists all data in a single memory-mapped file on disk, organizing information using B+ trees to facilitate sorted key iteration and efficient range queries. The project distinguishes itself through a hierarchical data organization model, allowing buckets to be nested within other buckets to create a tree-like structure. It employs a single-writer, multi-reader locking mechanism and copy-on-write transactions to ensure serializable isolation and data integrity. The system includes comprehensive data management capa

Android-ZBLibrary is a mobile framework providing core primitives for Android development, including a Model-View-Presenter framework for structural architecture, a network request wrapper, and a local data persistence layer. It also includes a library of reusable interface elements and a background task manager to maintain user interface responsiveness. The framework decouples business logic from user interfaces through its MVP implementation and manages external service integration via tools for HTTP communication, JSON processing, and response caching. The library covers a broad set of ca

redb is an embedded key-value store and ACID-compliant storage engine. It functions as a persistent storage system for saving and retrieving data as key-value pairs within a tree structure. The engine is built as an MVCC transactional database, utilizing multi-version concurrency control to manage simultaneous reads and writes without blocking. It employs a single-writer multi-reader model to ensure data consistency while allowing multiple threads to access the store. The system provides persistent state management and atomic transaction management to prevent data corruption during crashes.

d2-admin is an admin dashboard framework used to build back-office management interfaces. It provides a set of pre-configured layouts and themeable components, including foldable sidebars and draggable grid systems, to facilitate system oversight and control. The framework is distinguished by its multi-tab administration interface, which allows users to switch between pages and reorder tabs via drag and drop. It also features a dynamic translation system for multi-language interface localization and a dedicated toolset for tabular data management, enabling the import and export of data via CS

Badger is an embeddable key-value store written in Go that provides persistent data storage for byte keys and values. It is a persistent database that utilizes a tiered LSM tree storage model to optimize disk storage and retrieval efficiency. The system features an ACID transaction engine that ensures data integrity through serializable snapshot isolation and multi-version concurrency control. It also provides an encrypted key-value store with data-at-rest encryption and a managed encrypted key registry to secure stored information. The engine covers a broad set of capabilities including hig

This project is a curated collection of deployment files and configurations for hosting a wide variety of open-source services on a home server. It primarily utilizes Docker and Docker Compose to automate the orchestration, lifecycle management, and deployment of containerized applications. The repository provides a comprehensive suite for self-hosted infrastructure, covering network management tools, media streaming, and home automation. It includes specialized configurations for securing internal services via reverse proxies, WireGuard VPN tunnels, and automated SSL/TLS certificate manageme

Immutable.js is a library of persistent data structures and a functional state management toolkit. It provides a collection of immutable objects and arrays that prevent direct mutation to ensure predictable state management in JavaScript applications. The library utilizes structural sharing to efficiently create new versions of data without full copying and implements lazy sequence processing to chain data transformations that execute only when values are requested. It also supports batch mutation processing, allowing multiple changes to be applied to a temporary mutable copy before returning

WatermelonDB is an offline-first data synchronization engine and reactive database library designed for mobile and web applications. It provides a persistent storage layer backed by SQLite, enabling applications to maintain full functionality and data consistency while operating without an internet connection. The framework distinguishes itself through a reactive data binding system that automatically updates user interface components whenever underlying database records change. It utilizes schema-driven model mapping to generate type-safe interfaces and employs lazy object materialization to

This project is a memory-safe library implemented in Rust that provides a high-performance engine for managing shared, distributed data states. It functions as a conflict-free replicated data type implementation, enabling real-time collaborative editing and state synchronization across distributed systems without the need for a central server or manual conflict resolution. The library distinguishes itself through a cross-language binding framework that allows native applications in environments like Python, Swift, and WebAssembly to interact with the same shared data protocol. It utilizes a c

Couchbase Lite for iOS is an embedded NoSQL database engine designed for native mobile and desktop applications. It functions as a library within the application process, providing local document storage and structured querying capabilities that allow software to remain fully functional and responsive without an active internet connection. The library distinguishes itself through a replication engine that synchronizes local database changes with a central server to maintain consistent state across multiple devices. This synchronization process utilizes a delta-based protocol to transmit only

Omnivore is an open-source, self-hostable read-it-later application designed to centralize web articles, newsletters, and digital documents into a personal library. It functions as a comprehensive content archiver that captures web pages and stores them locally, ensuring permanent access and readability regardless of internet connectivity. The platform distinguishes itself through an event-sourced synchronization engine that maintains a consistent state across multiple devices by replaying user actions. It utilizes a headless web scraping service to extract clean text and metadata from raw we

Snowflake is a cross-platform mobile app starter designed for building iOS and Android applications using a single JavaScript codebase. It provides a pre-configured boilerplate to accelerate the initial development process for mobile applications. The project includes a Redux state management template for coordinating global application state and persisting user sessions, along with a REST API integration framework for communicating with remote or local servers via HTTP requests. It also features a localization system that maps user interface content into multiple languages based on the devic

Bolt is a single-file embedded key-value store for Go applications. It is an ACID transactional database that organizes data in B+trees on disk to provide efficient sorted key retrieval and range scans. The system uses a memory-mapped model to map the database file directly into the process address space for fast random-access reads. The project distinguishes itself through a multi-version concurrency control architecture that allows multiple simultaneous readers to access a consistent snapshot of data without blocking a writer. It employs a single-writer multi-reader locking model and uses a

go-cache is a thread-safe, in-memory key-value store for single-machine applications. It provides a local caching mechanism that stores objects in RAM to reduce redundant data retrieval and avoid the overhead of network protocols or serialization. The system features a persistent cache store that saves the in-memory state to a local file, allowing data recovery across application restarts. The project manages concurrent data access across multiple routines and implements time-to-live expiration for cached entries. A background process periodically scans the store to delete expired items and