EasySubs is a browser extension for language learning that enhances video watching on platforms like YouTube, Netflix, Coursera, and KinoPub. It provides interactive subtitles with translation capabilities, vocabulary export to learning services (Anki, LinguaLeo, Puzzle English), and UI customization features. The extension uses a content script to modify web pages, a background service worker for cross-tab communication, and a React-based popup for configuration. Built with React/TypeScript, Vite, and Effector for state management, it employs abstraction layers for video platforms, translation services, and learning integrations to handle the complexity of supporting multiple services with frequently changing UIs. The repository also includes a Next.js-based documentation site in the docs/ directory for marketing and user support.
FitMart is a full-stack fitness e-commerce application built with React 19, Node.js/Express 5, MongoDB (Mongoose 9), Firebase Authentication, and Razorpay payments. It provides a product catalog, shopping cart, checkout flow, order management, user profiles, fitness calculators (BMI, calorie), workout tracking, a rewards system, and an AI chatbot powered by Gemini. The admin dashboard includes KPI grids, customer segmentation, inventory management, sales reports, and bug tracking. The architecture is a monolith with separate client and server directories, using Docker for containerization and GitHub Actions for CI/CD. While the codebase is well-structured with modern patterns (Zod validation, atomic database operations, Redis caching), it suffers from incomplete features, hardcoded values, security gaps (dev admin bypass, hardcoded admin UID), inconsistent error contracts, and limited test coverage. The high number of open issues (276) suggests community engagement but also maintenance challenges.
Upstat is a self-hosted, open-source status monitoring and uptime tracking tool. The system consists of a Go (Fiber v2) backend API and a Next.js 15 web dashboard, deployed via Docker Compose with support for both PostgreSQL and SQLite databases. The backend periodically pings configurable HTTP endpoints, records heartbeats, calculates uptime percentages, and manages incidents triggered by status transitions. It integrates with multiple notification channels (Discord, Slack, Telegram, Ntfy, Gotify) and provides public status pages with real-time latency charts. The frontend uses shadcn/ui components, React Hook Form with Zod validation, and a custom client fetch wrapper for authenticated API calls. The monorepo also includes a documentation site (Fumadocs) and a static landing page. While the architecture is well-structured with clear separation of concerns (controllers, routes, models, utils), the codebase shows signs of technical drift including outdated dependencies, hardcoded secrets in Docker Compose files, committed SQLite database artifacts, and documentation inconsistencies between the manual API docs and generated OpenAPI spec. The project is functional and suitable for small to medium deployments but would benefit from dependency updates and cleanup before production use.
This repository provides a minimal, opinionated starter template for building React applications with Vite. It includes a pre-configured setup with TypeScript, Tailwind CSS v4, Biome for linting and formatting, Lefthook for git hooks, Turbo for task orchestration, and Renovate for automated dependency updates. The actual application code is trivial: a single-page app shell with lazy-loaded routes for an index page and a 404 page, wrapped in React Router's BrowserRouter. The template prioritizes modern tooling and developer experience but does not implement any business logic, custom components, or complex architecture. It is intended to be cloned and used as a starting point for new React projects, rather than as a standalone application.
This repository is an educational course on harness engineering for AI coding agents. It is a collection of lecture materials, code examples, and project templates that teach how to build environments, state management, verification, and control mechanisms for AI coding agents. The course is structured as 14 lectures and 8 projects, with a sample Electron knowledge-base app used as a running example. The repository is primarily documentation and educational content, with some reusable templates and scripts for harness creation and auditing.
This repository is a comprehensive frontend visual effects collection and demonstration platform. It contains over 100 self-contained demos and tools covering CSS animations, Canvas 2D/WebGL effects, Three.js 3D scenes, ECharts data visualizations, AI/ML integrations (TensorFlow.js for pose detection and body segmentation, MediaPipe, Tesseract.js OCR), and client-side media processing (image, video, PDF). The architecture is a React 18 single-page application (SPA) using TypeScript, Webpack 5, Ant Design, and react-intl for internationalization. All processing occurs entirely in the browser; there is no backend or persistent data store. The project serves as both a personal portfolio and a learning resource for advanced frontend techniques, but it is not a single-purpose production application. The code quality varies widely: some components demonstrate high craftsmanship (e.g., custom PNG encoder, image manipulation utilities, cross-page communication hook), while many others are boilerplate-heavy duplicates or exploratory demos. No automated tests are present, and the build output includes large minified chunks alongside source code, creating maintenance overhead.
Hayroo is a full-stack MERN e-commerce application built as a tutorial/demo project. It enables product browsing, cart management, checkout with Braintree sandbox payment, user authentication (JWT), and an admin dashboard for managing categories, products, orders, and slider images. The frontend uses React with Context API and useReducer for state management, while the backend is an Express.js REST API with MongoDB/Mongoose. The code follows standard patterns for a teaching project but lacks tests, CI/CD, and advanced optimizations. It is a functional, unremarkable implementation suitable for learning MERN stack concepts.
This repository implements a personal link-in-bio web application (moure.dev) built with Reflex, a Python web framework that compiles to a React frontend with a FastAPI backend. The application serves as a central hub for Brais Moure's social media profiles, programming courses, newsletter subscription, and sponsor showcases. It features two main pages: an index page with social links and a courses page listing educational resources. The architecture follows a modular pattern with separate components for UI elements (buttons, icons, headers, footers), a state management class for asynchronous data fetching, and a FastAPI sub-app that exposes REST endpoints for live Twitch status, featured content from Supabase, and event schedules from ConfigCat feature flags. The frontend is rendered using Radix UI primitives and includes client-side theming, analytics tracking (Google Analytics, Facebook Pixel), and a newsletter integration via Beehiiv. The codebase is primarily educational, accompanying a 13-hour video course on web development with Python. It demonstrates how to build a full-stack application using Reflex, integrate external APIs (Twitch, Supabase, ConfigCat), manage application state, and deploy via Docker or static export. The project includes CI/CD via GitHub Actions for automated static builds. While the application is functional and well-structured for its scope, it lacks automated tests and contains some commented-out code. The generated frontend assets are tightly coupled to specific Reflex and React versions, posing potential maintenance challenges during upgrades. External dependencies on Twitch, Supabase, and ConfigCat require valid credentials via environment variables, limiting out-of-the-box reproducibility.
This repository is a full-stack web application, 'BypassAIGC', functioning as an AI-powered academic writing assistant. Its core operational logic, confirmed by code analysis of its two-stage 'polish' and 'enhance' pipeline and configuration flags, is to rewrite text to evade detection by AIGC classifiers like GPTZero. It is a monolithic application built with a FastAPI backend and a React frontend, packaged for standalone deployment via PyInstaller. The codebase features a highly sophisticated, deterministic Word document formatting engine (`word_formatter`) that parses markdown into a Document AST, renders it to OOXML, validates the structure against a StyleSpec, and applies patch-based auto-corrections. This module demonstrates exceptional craftsmanship in document engineering. While functionally complete, the application suffers from significant technical debt. This includes critical security vulnerabilities (default secrets, permissive CORS, plaintext API key storage), ad-hoc database migrations, duplicated application entry points, and incomplete features (e.g., PDF export is a stub). The project is maintained but carries a high risk of technical drift, making it unsuitable for production deployment without substantial hardening.
This is a React library for feature toggle management, providing components and higher-order components to conditionally render UI based on enabled features. The library exposes a `FeatureToggles` provider, a `Feature` consumer component (with render prop or component swapping), a `configureFeature` curried HOC for creating pre-configured feature components, a `withFeatures` HOC to inject the features list, and a `useFeatures` hook for functional components. The code is well-structured, thoroughly tested, and follows a clean context-based architecture. However, the repository is clearly unmaintained: it targets Node 8, uses outdated Babel 6 presets, React 16, and has no dependency updates in years. The technical drift is high, making it risky for new projects without significant modernization. Despite this, the core patterns remain valid and could be extracted or used as a reference for implementing feature toggles in modern React.
DemoGPT is an open-source Python framework that provides two core capabilities: (1) an automatic Streamlit application generator that converts natural language descriptions into complete, runnable Streamlit apps through a multi-stage LLM pipeline (planning, task decomposition, code generation, assembly), and (2) the DemoGPT AgentHub, a modular library for building AI agents with built-in tools (web search, code execution, Wikipedia, weather, etc.), two agent types (ToolCallingAgent for single-step tasks, ReactAgent for multi-step reasoning), and a RAG (Retrieval Augmented Generation) system supporting Chroma, FAISS, and Pinecone vector stores. The codebase is primarily a library/application hybrid, with the Streamlit app acting as both a user interface and a demonstration of the generation pipeline. The architecture separates concerns into chains, prompts, task definitions, and controllers, but many components are tightly coupled to the specific generation pipeline. The AgentHub portion is more modular and reusable. Technical drift is medium: the code uses deprecated LangChain APIs (LLMChain, Chain.run), hardcodes older models like gpt-3.5-turbo-16k in some generated code, and has a broad dependency range. Maintenance appears active with recent commits and responsive issue triage, but the codebase would benefit from modernizing to LangChain's new LCEL syntax and updating default models.
Rocket Redis is a desktop GUI client for Redis databases built with Electron and React. It provides a clean interface to manage multiple Redis connections, browse databases, list and search keys, and view key contents (strings, hashes, lists, sets, sorted sets). The application uses a custom frameless window with OS-specific title bar controls and supports i18n via react-i18next. State is managed with Recoil atoms, and Redis connections are handled via the ioredis library. The codebase is well-structured with separate service layers for connection CRUD, database loading, and key content retrieval, along with a reusable toast notification system and form validation utilities. However, the project appears to be stale (dependencies frozen at 2020 versions, no recent activity) and exhibits significant technical drift, making it a functional but dated reference for Electron+Redis GUI patterns.
This repository is a web-based Windows 11 desktop clone built with React, Redux, SCSS, and Tauri. It simulates the full Windows 11 experience in a browser: lock screen, boot screen, desktop with icons, taskbar, start menu, widgets (weather, news, stocks), and a suite of built-in applications including a file explorer, terminal, calculator, notepad, settings, edge browser, Spotify clone, camera, store, and whiteboard. Internationalization supports English and Chinese. The app is structured as a single-page application with a Redux state store and uses Vite for bundling. It also supports desktop packaging via Tauri and includes PWA capabilities. Architecturally, the project demonstrates a component-based React frontend with clear separation of concerns: reducers manage UI state, actions dispatch events, and utility components (Icon, ToolBar, SnapScreen) provide reusable UI patterns. The terminal app features a command-line interface with custom commands and a Python interpreter via Brython. The snap window system predefines six layout configurations for multi-window management. Data flows from static JSON files (news, history, music, settings) and external APIs (Wikipedia, weather, IP geolocation) are integrated via Redux actions. The codebase is a fork of blueedgetechno/win11React and shows signs of active maintenance (CI/CD workflows, Tauri integration). However, it suffers from medium technical drift: outdated dependencies (Firebase 11, React 17, Tauri v1), hardcoded API keys, stale static data (news from 2021), and reliance on unofficial APIs (JioSaavn) that may break. No automated tests are present, and some features (e.g., camera) are incomplete. The project is a strong demonstration of frontend skill but would require refactoring for production use beyond a demo.
This repository contains the source code for SimpRead (įŽæĻ), a browser extension for Chrome and Firefox that provides an immersive reading mode, focus mode, annotation, and later-reading capabilities. The extension extracts article content from web pages, applies customizable typography and themes, and supports exporting to numerous services including Markdown, PDF, EPUB, Kindle, email, and cloud storage (Dropbox, WebDAV, Notion, Evernote, etc.). It includes a rules-based site adaptation engine (defined in `website_list.json`) to handle hundreds of specific websites, a plugin system for user-installed scripts, and a notice/focus system to manage reading sessions. The architecture follows a typical browser extension pattern: a background script (`background.js`) manages storage, OAuth, context menus, and cross-tab communication; content scripts (`contentscripts.js`) inject reading and focus modes into pages; and multiple options pages (`options/`) provide configuration, custom CSS, site management, and notice center. The UI is built with React 0.14.8 and a custom Material Design UI kit (`mduikit`), with heavy use of jQuery for DOM manipulation. State is managed through a central storage service (`storage.js`) that provides reactive reads/writes and versioned migration. External integrations are implemented as service classes with OAuth flows, and a message-action pattern coordinates between isolated script contexts. The codebase demonstrates a strong feature set but suffers from significant technical debt: very old dependencies (webpack 1, React 0.14), deprecated lifecycle patterns, extensive global DOM manipulation mixed with React, hardcoded CDN links and provider secrets, and comments indicating hacky browser workarounds. The site adaptation rule set is large but fragile, relying on exact CSS selectors and inline JavaScript that break when websites change. Despite these issues, the project provides a wealth of reusable patterns, particularly in its custom UI components, notification system, and storage abstraction.
This repository is an ESLint plugin (`@factory/eslint-plugin`) developed by Factory AI. It provides a suite of custom lint rules and shared configurations designed to enforce strict code organization, testing, and logging conventions. The codebase is fully AI-generated and explicitly unmaintained, intended for inspiration rather than direct import. It demonstrates high craftsmanship in AST manipulation (e.g., `jest-mock-require-actual`, `structured-logging` rules with auto-fix) and complex configuration curation (e.g., `frontend.js` config with extensive `no-restricted-syntax` selectors banning specific React/Next.js patterns). The rules enforce a highly opinionated architecture, including specific file naming conventions (`.page.tsx`, `.module.tsx`), mandatory middleware in route handlers, and structured logging over template literals. While the code quality and test coverage are strong, the plugin is technically drifted (ESLint 8.x API, TypeScript 5.x) and relies on outdated dependencies, limiting its direct applicability without significant modernization.
Estela is an open-source web scraping orchestration platform (analogous to Scrapy Cloud) for deploying, scheduling, and monitoring Scrapy-based spider projects on Kubernetes. It consists of a Django REST API backend with Celery for async task management, a React/TypeScript frontend with Ant Design, and a Kafka-based queue consumer for streaming scraped data into MongoDB. Core workflows include project management, spider deployment (Docker image build via Kaniko), job execution with configurable resource tiers, cron scheduling, data persistence settings, and a metering subsystem for usage tracking. The system relies on external dependencies such as Kubernetes, Kafka, MySQL, MongoDB, Redis, and object storage (MinIO/S3). The frontend provides interactive charts, a tour overlay for onboarding, and notification management. While functional and extensible, the codebase shows signs of age (outdated Django/Celery versions, class-heavy React components, duplicate logic in cron expression handling) and has incomplete test coverage.
Geist UI is an archived React UI component library and design system inspired by Vercel's design language. It provides a comprehensive set of 40+ components (Button, Card, Modal, Table, Input, Select, etc.), a flexible theming system with light/dark presets and custom theme creation, a proprietary scaling system for responsive sizing, and utility hooks (useClipboard, useClickAway, useKeyboard, useToasts, etc.). The repository also contains a full documentation site built with Next.js and MDX, featuring interactive playgrounds, attribute tables, and bilingual content (English/Chinese). The library is published as @geist-ui/core and supports tree-shaking, server-side rendering, and integration with Next.js, Remix, Create React App, and webpack. However, the project is archived and no longer receives active updates; its reliance on styled-jsx, deprecated test utilities (Enzyme), and older dependency versions pose compatibility risks for modern React and bundler ecosystems. The codebase demonstrates solid engineering practices with compound components, context-driven state management, and well-isolated hooks, making many parts reusable despite the project's dormant status.
ZhihuHelper is a desktop application built with Electron, React, and Node.js designed to scrape content from Zhihu (a Chinese Q&A platform) and export it to EPUB/HTML formats for offline reading. The application features a GUI for task configuration and logging, alongside a CLI interface powered by AdonisJS Ace. Core functionality includes fetching various Zhihu content types (answers, articles, pins, collections, etc.) via the platform's API, storing data in a local SQLite database, and generating formatted e-books with options for sorting, image quality selection, and automatic volume splitting. The architecture separates concerns into distinct layers: Electron main process for window management and IPC, React renderer for the UI, API wrappers for Zhihu endpoints, Knex-based ORM models for data persistence, and a custom EPUB generation library. While the tool effectively accomplishes its stated purpose, it exhibits signs of technical drift due to outdated dependencies and reliance on Zhihu's undocumented API, which necessitates frequent maintenance to remain functional.
This repository implements a React library for building forms based on GraphQL APIs, specifically designed to work with Apollo Client. The library provides a code generation CLI tool that extracts GraphQL mutation information and converts it to JSON Schema, along with a React component that renders forms and handles submission via GraphQL mutations. The architecture consists of: 1. A CLI tool (`lib/cli.ts`) for generating schema and type definitions from GraphQL endpoints 2. Core form logic in `lib/forms/` including the main `ApolloForm` component, utilities for schema processing, and rendering customization 3. Integration with React-jsonschema-form as the underlying form engine Key features include conditional fields, custom validation, theming support, and automatic JSON Schema generation from GraphQL schemas. The library demonstrates particular strength in its JSON Schema manipulation utilities, which handle complex operations like resolving $ref references and applying conditional logic to schemas.
react-sortable-tree is a React component library that provides a drag-and-drop sortable tree view for hierarchical data. It renders nested arrays of nodes with expand/collapse, virtualization via react-virtualized, search with highlighting, theming, and extensive callback hooks for move and visibility changes. The library is not actively maintained; the last release was in 2020, and the README explicitly disclaims maintenance. The codebase is well-architected with clean separation of concerns: pure tree-data utility functions (walk, map, insertNode, etc.) separated from React rendering, a DndManager class that wraps react-dnd, and a theming system. Despite its staleness, the core tree manipulation algorithms are high-quality and extractable for other projects. The library depends on outdated versions of React (16) and react-dnd (11), and uses react-virtualized instead of the more modern react-window.