Coral is an open-source, multi-tenant comment moderation platform developed by Vox Media. It provides a full-stack application with embedded commenting widgets (stream), a comprehensive admin panel for moderation, configuration, and community management, an authentication system supporting local, OAuth2/OIDC, Google, Facebook, SSO, and account management pages. The system architecture consists of a Node.js/Express server with Apollo GraphQL, MongoDB for persistence, Redis for caching and pub/sub, and Bull for job queues. The client uses React with Relay for GraphQL data fetching, and is organized into several bundles: stream (the embeddable comment widget), admin, auth, account, install, count, and embed. The core data flow involves comments being submitted via GraphQL mutations, processed through a modular pipeline (spam detection, word list filtering, toxicity analysis via Perspective API, external moderation phases, and pre-moderation rules), stored in MongoDB, and then distributed via GraphQL subscriptions and notifications (email, Slack, webhooks). The codebase is extensive and well-tested, though it exhibits some legacy patterns (recompose HOCs, partial migration from class components to hooks, duplicated utility code between client and server scripts).
This repository is a lightweight JavaScript library that provides a feature-rich wrapper around the browser's `localStorage` and `sessionStorage` APIs. It offers a unified API for storing, retrieving, and manipulating JSON data, with support for namespacing, multiple storage areas (local, session, page, custom), and a plugin system for extensions. The core module (`src/store2.js`) implements a Store constructor that creates namespace-aware stores, with methods like `get`, `set`, `remove`, `clear`, `each`, `keys`, `transact`, and `add`. It also includes a fake storage fallback for environments where Web Storage is unavailable. The architecture is modular: the core is augmented by optional extension files (e.g., caching, array operations, event handling, cookie backing) that hook into internal methods via `store._`. The library is production-ready, with extensive unit tests and CI via Travis CI (though using Node.js 9, which is outdated). Key entry points are the `store` function and its namespace/area methods, which expose the entire API.
TiddlyDesktop is a desktop application that serves as a custom web browser for working with locally stored TiddlyWiki files and folders. Built on nw.js (formerly node-webkit), it provides a native windowing system to open, edit, save, and manage multiple TiddlyWiki instances. The application includes a backstage configuration wiki for managing settings, a wiki list window for organizing wikis, and support for both single-file HTML wikis (TiddlyWiki 5 and Classic) and wiki folder formats. It implements file saving via a TiddlyFox-like protocol, automatic backups, and drag-and-drop wiki registration. The architecture is modular, with separate window classes for wiki files, wiki folders, and backstage tiddlers, all managed by a central window list. The codebase is well-structured and demonstrates solid engineering practices for an nw.js application.
This repository is a TypeScript-based web library designed for browser screenshot capture and annotation. It functions as a plugin that initializes a DOM overlay, captures screen content via multiple strategies (WebRTC, html2canvas, DOM rendering), and provides a rich annotation interface for drawing shapes, text, and cropping. The architecture is monolithic, bundling into UMD, ESM, and CommonJS formats via Rollup, and utilizes MobX for reactive state management across canvas elements and UI components. The system relies on a core entry point in `src/main.ts` which exports the `ScreenShot` class. Data flows from the source manager selecting a capture strategy, rendering to an HTML5 Canvas, and then managing user interactions through a centralized store system. External dependencies include `html2canvas` for DOM capture, `nanoid` for ID generation, and `mobx` for state. The codebase includes comprehensive unit testing via Jest and E2E testing via Playwright, indicating a focus on reliability. While the library is well-structured with clear separation of concerns between application logic, canvas features, and shared utilities, it is tightly coupled to the browser environment and specific canvas element types. The presence of a `TEST_IMPROVEMENT_PLAN.md` suggests ongoing refinement of test coverage, but the core architecture remains stable and functional for its intended domain of web-based screenshot tools.
PythonMonkey is a Python C extension that embeds Mozilla's SpiderMonkey JavaScript engine, enabling seamless bidirectional interop between Python and JavaScript. It allows Python code to evaluate JS expressions, require CommonJS modules (including .py modules), and manipulate JS objects as native Python types via proxy objects with shared memory semantics. The library integrates JS promises and timers with Python's asyncio event loop, and provides a CLI tool (pmjs) similar to Node.js. The architecture is a native module with extensive C++ proxy handlers for type coercion, a CommonJS module system, and built-in JS modules (console, timers, URL, XMLHttpRequest). External dependencies include SpiderMonkey (built from source), Python 3.8–3.13, npm, cmake, and rust. The codebase is actively maintained by Distributive Corp. and reached MVP in September 2024, but carries medium technical drift due to tight coupling to a specific SpiderMonkey version and Python version shims.
Steam Achievement Notifier (SAN) is a feature-rich Electron desktop application that monitors Steam and RetroAchievements unlock events and displays highly customizable on-screen notifications. It leverages the Steamworks API for real-time achievement tracking without requiring an API key, and integrates with RetroAchievements via emulator log file parsing. The application provides extensive customisation – multiple notification presets (consoles, Steam Deck, custom), per-type themes (colors, fonts, icons, glow, masks, positions), screenshot overlays, streaming overlays for OBS, Discord webhook posting, game completion timer, and a diagnostics troubleshooter. Architecture is multi-process: a main process handles window management and IPC, a renderer process displays the settings/customiser UI, a worker process continuously polls Steam for game state and achievements, and a RetroAchievements worker monitors emulator logs. Communication is event-driven with well-defined IPC channels. The project includes Rust native modules for keypress simulation, HDR screenshot capture, and high-performance process watchers, bundled as precompiled binaries. The codebase is actively maintained with regular releases, comprehensive localization (25+ languages), and detailed inline documentation (tooltips). While architecturally sound with clean separation of concerns, some modules (e.g., sanhelper.ts) are monolithic and tightly coupled to the application's config and UI, which may hinder isolated reuse. The translation files are large and duplicative, requiring coordinated updates across languages.
This repository is a Node.js GitHub Bot that automates tasks in response to GitHub and Jenkins webhooks. It uses an Express.js server to receive webhooks, validates GitHub signatures, and emits normalized events via a central event emitter. Scripts in the `scripts` directory listen for these events to perform actions such as commenting on pull requests, updating GitHub status checks based on Jenkins builds, and enforcing CODEOWNERS reviews. The architecture separates webhook reception from processing, allowing for extensibility through additional scripts.
This repository is a mature, production-grade WAMP v2 client library for Node.js and browsers. The actual code implements the Web Application Messaging Protocol with full pub/sub and RPC support over WebSocket, including auto-reconnect, multiple serializers (JSON, CBOR, MsgPack), and authentication methods (ticket, WAMP-CRA, cryptosign). The architecture is modular: a core Wampy class in `src/wampy.ts` accepts pluggable serializers via a common interface, and authentication plugins are registered in a hashmap. The library also includes a CLI tool (`cmd/cli.ts`) for rapid WAMP API debugging. External dependencies are minimal (WebSocket, Node.js crypto for cryptosign). The codebase is written in TypeScript with strict mode, dual ESM/CJS builds, and a comprehensive test suite covering connectivity, PubSub, RPC, and advanced features like progressive calls and Payload PassThru Mode. Despite large test files and some legacy patterns, the code is well-structured and follows promises/async-await throughout.
TermUI is a comprehensive TypeScript monorepo providing a full-featured terminal UI framework for building rich, interactive command-line applications. It includes a custom JSX runtime with hooks, reconciliation, and portals; a theme engine (TSS) with CSS-like syntax and 26 built-in themes; a widget library spanning layout, input, display, data visualization, and feedback components; a motion system with spring physics and composable animations; a client-side router; a Zustand-like state store; adapters for external integrations (AI, Git, GitHub, clipboard, keychain); real-time system data hooks (CPU, memory, disk, Docker); a CLI scaffolding tool; and a dev server with hot reload. The framework is designed to offer a React-like development experience for terminal UIs, supporting JSX/TSX, keyboard and mouse input, focus management, accessibility (OSC 133), and unicode/ASCII fallbacks across 14+ packages with over 5000 tests.
This repository implements an MCP (Model Context Protocol) server that provides semantic code search capabilities for AI assistants. It enables developers to search their codebases by meaning rather than just keywords, using local AI models to ensure privacy and avoid external API calls. The system features semantic code search using embeddings (nomic-embed-text-v1.5 with MRL), incremental indexing with file watching, efficient SQLite-based caching of embeddings, cross-platform package version checking across 20+ ecosystems, workspace switching capabilities, and resource throttling to prevent system overload during indexing. The codebase demonstrates strong engineering practices with proper error handling, modular design, and attention to user experience.
Foundry is an opinionated toolkit that centralizes and automates the configuration of code quality tools for JavaScript/TypeScript projects. It bundles and exposes composable ESLint flat configs, Biome configuration, Stylelint configuration, Husky hooks, and lint-staged setup. The CLI (`foundry init`) detects installed frameworks and dependencies (React, Next.js, Jest, etc.), generates tailored config files, and updates package.json scripts. The package primarily serves as a shared, versioned dependency that enforces consistent linting and formatting across multiple projects within an organization. The architecture is a library of configuration objects combined with a thin CLI wrapper, and the code is well-structured, modular, and thoroughly tested.
This repository is the Front End Interview Handbook, a comprehensive collection of front-end interview questions and answers covering HTML, CSS, JavaScript, system design, behavioral topics, and company-specific experiences. It is built as a static documentation site using Docusaurus 3, with a custom theme that includes sidebar advertisements and a modified table of contents. The site supports 10 languages through i18n and is deployed at frontendinterviewhandbook.com. While primarily a content repository, it demonstrates solid software engineering practices in its Docusaurus configuration, custom theme components, and multilingual setup. The content is curated from the h5bp/Front-end-Developer-Interview-Questions repository and community contributions, with references to authoritative sources. The repository also includes blog posts and success stories. It is not a traditional application or data pipeline but a hybrid of a documentation site and a curated knowledge base.
NW.js is a desktop application runtime that integrates Chromium and Node.js, enabling developers to build native desktop applications using web technologies (HTML, CSS, JavaScript). The codebase functions as a hybrid framework where web content can access native OS APIs and Node.js modules can be loaded directly into the browser context. It operates on a multi-process architecture typical of Chromium-based projects, with distinct browser, renderer, and utility processes. The system relies heavily on upstream Chromium and Node.js versions, requiring constant synchronization to maintain compatibility and security. It supports cross-platform deployment (Windows, macOS, Linux) with platform-specific implementations for UI components, file dialogs, and system integration.
Carbon is a Next.js web application for creating and sharing beautiful images of source code. It provides a CodeMirror-based editor with extensive customization: syntax themes (30+ built-in), fonts (13 options), background colors/images (including Unsplash integration), window themes, padding, shadows, and line numbers. Users can import code via paste, file drop, or GitHub Gist URLs. Export options include PNG/SVG at multiple resolutions, clipboard copy, Twitter sharing, Imgur upload, and embed codes. Saved snippets persist via Firebase authentication with automatic Twitter/Slack unfurling. The app runs as a PWA for offline use. Architecture is a Next.js 12 monolith with API routes for oEmbed and server-side image generation (Puppeteer/Chrome AWS Lambda). State is managed through URL parameters (with base64-encoded complex state), localStorage, and React state. The codebase demonstrates solid engineering with custom CodeMirror modes for 6 languages, a sophisticated theme builder, and well-encapsulated UI components.
Clipboard.js is a lightweight JavaScript library that provides a modern, no-Flash way to copy or cut text to the clipboard. It operates as a browser library, using event delegation via the `good-listener` package and the deprecated `document.execCommand` API. The core class `ClipboardJS` can be instantiated with a DOM selector, element, or NodeList, and it automatically listens for click events to trigger copy/cut actions based on HTML data attributes (`data-clipboard-text`, `data-clipboard-target`, `data-clipboard-action`). It also exposes static `copy()` and `cut()` methods for programmatic use, and emits custom `success` and `error` events. The library includes a fallback mechanism using a temporary textarea element for browsers that do not support selecting hidden elements. It is well-tested, has TypeScript definitions, and is distributed as a UMD bundle. The architecture is a simple monolith with a single entry point and isolated action modules.
FlowGram is a comprehensive, production-grade visual workflow development framework from ByteDance. The codebase implements two distinct editing paradigms — fixed-layout (automatic positioning with composite nodes like loops, branches) and free-layout (node-position-free with lines) — both built on a shared plugin architecture using inversify for dependency injection. The framework includes a form engine with reactive fields, validation, and effects; a variable engine with AST-based type inference and scoped lifecycle; and a runtime engine capable of executing workflows with executors for LLM, HTTP, code (QuickJS sandbox), and conditions. The repository contains over 40 packages managed via Rush monorepo, encompassing core libraries, plugins (history, minimap, auto-layout, group, snap, clipboard, export), UI material libraries (Semi UI, Ant Design), a CLI tool for scaffolding, multiple demo applications, and comprehensive documentation. The system is actively maintained with regular commits, CI workflows, and E2E tests. Notable technical decisions include a local fork of the use-gesture library for canvas interaction, heavy decorator-based IoC, and support for both React 17 and 18. While the architecture is well-structured and extensible, the codebase shows signs of duplication between fixed and free layouts, numerous demo-specific components, and some deprecated APIs that indicate ongoing refactoring.
Taro UI is a multi-platform UI component library designed for the Taro framework, enabling developers to build applications that run on WeChat Mini Program, H5, React Native, Alipay, and other platforms with a single codebase. The library provides over 40 reusable UI components (including form controls, layout elements, navigation tools, and feedback mechanisms) with consistent APIs across platforms. Architecture follows a monorepo structure with core components in packages/taro-ui/src, platform-specific adaptations in packages/taro-ui/rn, documentation built with VitePress, and multiple demo applications showcasing usage. The library relies on Taro as a peer dependency and utilizes utilities like classnames and dayjs for cross-platform compatibility. Recent active maintenance has included migration to Function Components + Hooks, build system upgrades to tsup, TypeScript 5.3 adoption, and CSS precompilation efforts to address prior technical debt.
This repository is the source code for the webgl2fundamentals.org educational website, a comprehensive, multi-language tutorial series for WebGL2. It is not a standalone application or library, but a static site built from markdown lessons and hundreds of interactive HTML/JavaScript example pages. The code includes reusable utility libraries for matrix math (m4.js, 3d-math.js), WebGL boilerplate (webgl-utils.js), lesson helpers, and a sophisticated interactive WebGL state diagram tool. The build system uses Grunt and custom lesson builders to generate the site. While the core educational content is well-maintained and pedagogically sound, the repository contains some legacy code (tdl library, old jQuery plugins) and many partially translated lessons, indicating ongoing maintenance but with some technical debt.
Turms is a production-grade, open-source instant messaging engine designed for 100K to 10M concurrent users. The system follows a microservices architecture with two core Java/Spring Boot servers: turms-gateway (handles client connections, authentication, session management, and push) and turms-service (implements business logic for messaging, groups, users, conversations, storage, and admin API). Both servers are built on a reactive stack (Project Reactor, Netty) for non-blocking I/O and high throughput. The platform includes a Vue.js admin UI (turms-admin), multiple client SDKs (JavaScript, Kotlin, Swift, Dart, C++), a Flutter chat demo, and a plugin system for extensibility (anti-spam, push notifications, MinIO storage, Rasa chatbot, LiveKit conferencing). Data is stored in MongoDB (sharded), Redis (session, blocklist, sequence IDs), and optionally Elasticsearch for full-text search. The codebase demonstrates strong engineering practices: custom RPC codecs for cluster communication, a property metadata framework for configuration validation, thread-safe rate limiting, and a well-defined plugin extension point system. While primarily an application, it includes an AI serving module (PaddleOCR) for content moderation, but this is a minor component. The repository is actively maintained with frequent commits, comprehensive CI/CD pipelines, and Terraform deployment scripts.
This repository is the source and build system for the multi-language edition of the classic computer science textbook *Structure and Interpretation of Computer Programs* (SICP). It contains the full text, exercises, and code snippets in XML, organized by chapter and section, for the original Scheme version as well as modern adaptations in JavaScript and Python. The build toolchain, implemented in TypeScript and JavaScript, parses the XML into multiple output formats: PDF (via LaTeX), a static HTML web edition, a JSON edition for the interactive Source Academy frontend, Markdown, and standalone program files. The system handles cross-references, code snippet extraction with dependency resolution, figure inclusion, index generation, and search index construction. The repository also includes CI/CD pipelines for testing generated programs against actual language runtimes (Node, CPython, MIT Scheme) and deploying the web edition to GitHub Pages. Additionally, AI-generated chatbot knowledge base modules for the Python edition are checked in. The codebase is well-structured with a clean edition abstraction and a modular processing pipeline, though it is tightly coupled to the SICP XML schema and the Source Academy ecosystem.