This is a monorepo of six AI agent skills (SKILL.md format) for creative content generation, targeting Claude Code, Cursor, Codex CLI, and other compatible agents. Each skill is a self-contained package with agent instructions, reference libraries, scaffold scripts, and optional companion websites. The skills enable agents to: generate beautiful single-file HTML articles (beautiful-article), create and edit images via GPT-4o (gpt-image-2), retrieve knowledge from local files (kb-retriever), produce deterministic motion-graphics videos with audio (motion-showreel), design polished web pages with anti-AI-cliché rules (web-design-engineer), and build click-driven video presentations with TTS (web-video-presentation). The repository also includes release automation (zero-dependency Node scripts, GitHub Actions), a Claude Code plugin marketplace entry, and two showcase websites (Vite+React+TypeScript). While primarily an application toolkit, it contains structured prompt template libraries and design reference catalogs that resemble curated data assets. The codebase demonstrates high engineering craftsmanship with deterministic rendering pipelines, a session-based audio synthesizer, design token systems, and comprehensive test coverage for the motion-showreel pipeline.
Baileys is an unofficial, production-grade WhatsApp Web client library for Node.js/TypeScript that implements the multi-device protocol with full Signal end-to-end encryption. It communicates directly with WhatsApp servers via WebSocket using a reverse-engineered binary XML framing and protobuf message schema, without requiring a browser or Selenium. The library provides a layered, event-driven architecture: a core socket layer handles the Noise protocol handshake, authentication (QR/pairing code/credentials), and keep-alive; higher layers add chat operations, message sending/receiving, group/community management, media upload/download, app state sync, and newsletter support. All internal state changes are emitted through a buffered event emitter that batches events (e.g., `messages.upsert`, `chats.upsert`, `connection.update`) for efficient consumer processing. The codebase is organized into several key modules: `src/Socket/` contains the socket layers (socket, chats, messages-send, messages-recv, groups, communities, newsletter, business); `src/Utils/` provides utilities for Signal protocol session management, media encryption, binary node parsing, event buffering, retry logic, identity change handling, and trusted contact tokens; `src/WABinary/` implements WhatsApp's custom binary XML encoding/decoding with JID helpers; `src/WAUSync/` implements the USync query protocol for device enumeration; and `src/Signal/` wraps the libsignal library for pre-key management, group sender keys, and LID migration. The library depends on external packages such as `libsignal`, `ws`, `protobufjs`, `@hapi/boom`, `pino`, `lru-cache`, `async-mutex`, and optional media processing libraries (`sharp`, `jimp`, `link-preview-js`). Baileys is designed for integration into larger applications (bots, automation, analytics) and exposes a comprehensive API for sending/receiving messages, managing groups, syncing chat history, handling media, and reacting to real-time events. It includes extensive unit and end-to-end tests, a protobuf extraction tool (`proto-extract/`) that scrapes WhatsApp Web's JavaScript to regenerate the `.proto` schema, and a version update script that fetches the latest WhatsApp Web version. The library is actively maintained with frequent commits, CI/CD pipelines, and a clear migration guide for breaking changes.
inshellisense is a terminal-native runtime that provides IDE-style autocomplete for shells. It integrates with shells via OSC sequences to display real-time suggestions as users type, drawing from the autocomplete project's database of 600+ command line tools. The architecture consists of a CLI entry point, runtime components for parsing and generating suggestions, UI components for rendering and managing suggestions, and shell integration scripts for various shells (bash, zsh, fish, powershell, etc.). Key features include keybindings for navigation (tab, up/down, esc), shell-specific configuration generation, and performance monitoring.
This repository defines a reusable AI agent skill for role-playing as Zhang Xuefeng, a Chinese education influencer. The core artifact is SKILL.md, a meticulously crafted markdown file with YAML frontmatter that encodes five mental models, eight decision heuristics, a complete expression DNA, and an agentic workflow (research → analyze → respond). It is not a running service or library; it is a configuration file consumed by compatible agent runtimes (Claude Code, Codex, Cursor, etc.) to transform the agent's behavior. The repository also includes six research files (references/research/) that document the persona's writings, conversations, expression style, external views, decisions, and timeline, serving as the evidence base for the skill. The skill demonstrates advanced prompt engineering, cognitive modeling, and agentic protocol design, making it a high-quality example of the Agent Skills pattern. It is actively maintained and has no technical drift as it consists solely of static markdown files.
Vicinae is a cross-platform desktop launcher and productivity tool written in modern C++20/23 with Qt6 and QML, inspired by Raycast. It provides a single keyboard-driven interface for launching applications, searching files, managing clipboard history, switching windows and workspaces, controlling media, running script commands, browsing fonts, picking emoji, and more. The system runs as a background server process with a CLI client, a file indexing subprocess, and a browser extension for tab management. It features a first-class extension system using TypeScript and Node.js, a custom fuzzy search library, an XDG desktop entry parser, encrypted clipboard storage, and deep platform integration for Linux (Wayland/X11, GNOME, KDE, Hyprland), macOS, and Windows. The architecture is modular with abstract service backends and a service registry for dependency injection.
OpenCC (Open Chinese Convert) is a deterministic, dictionary-based Chinese text conversion library and CLI tool that converts between Simplified Chinese, Traditional Chinese, and regional variants (Taiwan, Hong Kong, Japan), including experimental Small Seal Script (Unicode 18.0). It is used in production by input method engines (RIME, fcitx), dictionary tools (GoldenDict), and NLP pipelines for text normalization and preprocessing. The core is a C++ library with a plugin-based segmentation system (built-in mmseg, optional jieba). Conversion is config-driven via JSON files that define normalization, segmentation, and a chain of dictionary groups with match policies (short_circuit, union). Dictionaries are compiled from text files into binary formats (marisa-trie .ocd2, legacy .ocd). The library exposes C, C++, Python (pybind11), and Node.js (N-API) APIs. A CLI tool provides conversion, inspection, ambiguity detection, and dictionary management. Data flows: text input is segmented, then each segment is looked up in a chain of dictionaries (character, phrase, regional variants). The first match is used (short_circuit) or all matches are unioned. The result is reassembled. The system supports streaming conversion with bounded memory via chunked processing. External dependencies include marisa-trie, darts-clone, rapidjson, pybind11, Google Test, and Google Benchmark; optional jieba (C++ fork) for segmentation plugin.
Sioyek is a cross-platform PDF viewer optimized for reading research papers and technical books. Built with Qt, OpenGL, and MuPDF, it provides a rich set of features including multi-threaded rendering, annotation management (highlights, bookmarks, portals, freehand drawings), SyncTeX integration for LaTeX forward/inverse search, fuzzy text search, and a customizable command-driven interface. The architecture follows a modular design with a central MainWidget orchestrating UI state, a Document model for PDF handling, a PdfRenderer for threaded rendering, and a DatabaseManager for persistent annotation storage. The application supports both desktop and touch-optimized interfaces, with platform-specific code for Windows, macOS, Linux, and Android. While primarily an application, Sioyek incorporates data-oriented features such as SQLite-based annotation persistence, checksum-based document identification, and integration with external research tools (Google Scholar, arXiv). The repository also includes scripts for paper downloading, text-to-speech, and embedding annotations, as well as precomputed embedding data files (embedding.npy, linear.npy) likely used for text summarization or search enhancement. The codebase demonstrates strong engineering practices with reusable components like a fuzzy matching library (fzf), a SyncTeX parser, a type-safe configuration system, and a set of QML touch UI widgets. However, it also exhibits some technical debt in the form of global state, large monolithic files (main_widget.h), and platform-specific conditionals scattered throughout.
Watermill is a Go library for building message-driven and event-driven applications. It is not a standalone service; applications embed it and use the core Publisher/Subscriber interfaces to communicate with brokers such as Kafka, RabbitMQ, NATS, Redis Streams, Google Cloud Pub/Sub, AWS SNS/SQS, SQL databases, or an in-memory Go channel. This repository contains the core library, reusable components, runnable examples, and small CLI tools, while broker-specific adapters and some integrations live in separate modules. The architecture is layered. At the bottom are the low-level Pub/Sub abstractions and the Message object with UUID metadata, payload, and Ack/Nack lifecycle semantics. The middle layer is the Router, which wires handlers into consumption loops and supports middleware and publisher/subscriber decorators. On top of that, optional components implement CQRS event/command buses and processors, topic forwarding, request-reply, delayed publishing, metrics, fan-in/fan-out, and requeuing. Middleware covers retry with exponential backoff, poison queues, deduplication, throttling, circuit breaking, correlation IDs, timeout enforcement, and panic recovery. The repository is extensively tested, including a universal pub/sub conformance suite intended for adapter authors to reuse, and GoChannel serves as a complete in-memory reference implementation. The examples demonstrate real production patterns: CQRS with protobuf, ordered events, exactly-once delivery counters, outbox/transactional event forwarding, server-sent event feeds, webhook ingestion, and consumer groups. There is no data research component; this is purely a software library/application framework.
This repository serves as a curated reference guide for web designers and developers seeking to add design flair, user delight, and whimsy to their products. Organized as an extensive markdown document, it provides links and explanations across numerous design categories including CSS frameworks, typography, color theory, layout techniques, icons, animations, and UX improvements. The Spark Joy philosophy emphasizes thoughtful, delightful details that enhance user experience beyond mere functionality. While primarily a collection of external resources, the repository contains original value in its organization, explanations, and reusable code patterns. Most notably, it presents several implementable techniques: a responsive CSS layout system for content breakout, an optimized web font loading strategy, and performance-focused meta tags with resource hints. These components demonstrate practical engineering solutions to common frontend challenges. The repository is actively maintained with recent updates ensuring recommendations remain current. It functions as a valuable reference tool rather than a traditional application, offering designers and developers a comprehensive starting point for exploring modern web design techniques and resources while emphasizing the importance of subtle, joy-inducing details in product design.
The Open 3D Engine (O3DE) is a modular, open-source 3D game engine designed for developing AAA games, simulations, and interactive 3D content. It employs a component-based architecture with a core framework (AzCore, AzFramework, AzToolsFramework) and extensible gems for specialized functionality such as rendering (Atom), physics (PhysX), animation (EMotionFX), and UI (LyShine). The engine emphasizes data-driven design through reflection and serialization systems, and uses an event-driven communication pattern (EBus) for loose coupling between systems. Key architectural features include an entity-component-system (ECS) for game objects, a flexible asset processing pipeline that converts source assets into runtime-optimized formats, and a multi-platform rendering abstraction (RHI) supporting Vulkan, DirectX 12, and Metal. The engine provides extensive editor tools for content creation, including a scene editor, asset browser, and visual scripting system (ScriptCanvas). Cross-platform support is achieved through platform-specific trait files and abstraction layers, enabling deployment to Windows, Linux, macOS, Android, and iOS. The engine demonstrates strong engineering practices in its core systems: the EBus implementation offers a sophisticated, policy-based event bus; the reflection system enables serialization, behavior context binding, and editor integration; and the Interface pattern provides a flexible singleton mechanism. While the codebase shows signs of platform-specific duplication and some deprecated code, active maintenance and a clear modular structure help manage technical debt. O3DE is suitable for reuse in projects requiring a full-featured game engine or as a source of reusable patterns for engine development.
bpmn-js is a mature, extensible JavaScript library for rendering and editing BPMN 2.0 diagrams in the browser. It provides a full-featured modeler (Viewer, NavigatedViewer, Modeler) built on top of diagram-js, with support for import/export of BPMN XML and SVG, undo/redo, copy/paste, element replacement, grid snapping, auto-layout, and a rich set of modeling behaviors that enforce BPMN semantic rules. The architecture follows a modular dependency injection pattern (didi) with event-driven communication, command interceptors for undoable operations, and pluggable providers for context pads, palettes, popup menus, and renderers. The codebase is well-tested with hundreds of integration and unit tests, and includes benchmarks for large diagrams. It is actively maintained by the bpmn.io team and used widely in workflow and process automation tools.
Syft is a production-grade CLI tool and Go library for generating Software Bills of Materials (SBOMs) from container images, filesystems, directories, and OCI artifacts. It detects and catalogs packages across 40+ ecosystems (Alpine, Debian, RPM, Python, Java, Go, Ruby, Rust, JavaScript, .NET, etc.) by parsing lockfiles, package databases, binary metadata, and source manifests. The tool outputs SBOMs in multiple formats including CycloneDX (JSON/XML), SPDX (JSON/tag-value), Syft JSON, and GitHub Dependency Snapshots, with version-aware encoding and decoding. Architecturally, Syft uses a modular cataloger system where each ecosystem implements a `generic.Cataloger` with parser functions registered by file globs or MIME types. A task-based pipeline orchestrates file indexing, package cataloging, dependency resolution, and relationship linking. The system supports both library integration via `syft.CreateSBOM()` and a CLI with cobra commands (`scan`, `attest`, `convert`, `cataloger`). A bubbletea-based TUI provides real-time progress feedback during image pulls and cataloging. External dependencies include `stereoscope` for container image access, `cosign` for attestation signing, and `go-partybus` for event-driven UI. Key entry points include `cmd/syft/main.go` (CLI), `syft/create_sbom.go` (library API), `syft/get_source.go` (source resolution), and the format encoders/decoders in `syft/format/`. The codebase demonstrates strong engineering practices: extensive test coverage (unit, integration, snapshot), CI/CD with GitHub Actions, auto-generated JSON schemas, and drift-check scripts for capabilities and schema. Notable reusable components include the generic cataloger framework, the dependency resolver, and the file resolver abstraction.
YARP (Yet Another Reverse Proxy) is a high-performance, extensible reverse proxy toolkit for .NET, built on ASP.NET Core. It provides a library and samples for creating custom proxy servers with features including request forwarding, load balancing (random, round-robin, least-requests, power-of-two-choices), active and passive health checks, session affinity (cookie, hash, ARR, custom header), request/response transforms, and telemetry consumption. The architecture is middleware-based, with a pipeline that includes routing, load balancing, session affinity, health checks, and delegation (Http.sys). Configuration is driven by immutable records and supports dynamic reload via change tokens. YARP also includes a Kubernetes Ingress Controller module that watches Ingress, Service, Endpoint, and Secret resources to dynamically configure the proxy. The codebase demonstrates strong engineering practices: extensive unit and functional tests, pluggable policy interfaces, efficient stream copying with telemetry, and a transform builder pattern for declarative request/response modifications. It is actively maintained by Microsoft and used in production scenarios.
oclif is a self-hosting TypeScript CLI for building and releasing oclif-based command-line tools. In production it acts as the Open CLI Framework toolchain: it scaffolds new CLI projects from EJS templates (generate/init), generates command manifests and README documentation, packages CLIs into tarballs, .deb, macOS .pkg, and Windows NSIS installers, uploads artifacts to S3, and promotes versions across release channels. The codebase is a single package built on @oclif/core, with entry points at bin/run.js and src/index.ts (which exports `run`). It is best described as a developer-tools CLI plus an automated software distribution pipeline, not a data/research repository.
Crawlee is a production-grade Python web scraping and browser automation framework developed by Apify. It provides a unified async API for both static HTTP crawling (BeautifulSoup, Parsel, raw HTTP) and headless browser automation (Playwright, Stagehand), with an adaptive mode that dynamically chooses between them based on page characteristics. The architecture is modular: a context pipeline chains pre-navigation hooks, HTTP execution (via pluggable clients like httpx, curl-impersonate, or impit), parsing, and post-processing before dispatching to user-defined router handlers. Storage is abstracted behind Dataset, KeyValueStore, and RequestQueue interfaces with multiple backends (memory, filesystem, SQL, Redis). The framework includes autoscaling, session management, proxy rotation, browser fingerprint generation for anti-blocking, OpenTelemetry instrumentation, and a CLI for project scaffolding. It is designed for large-scale crawling with state persistence across runs and supports deployment on Apify, AWS Lambda, and Google Cloud Run.
fs-extra is a Node.js library that extends the native `fs` module with additional file system operations and promise support. It provides drop-in replacement for `fs` with methods like `copy`, `move`, `remove`, `ensureDir`, `outputFile`, `readJson`, `writeJson`, and more. The library uses `graceful-fs` to prevent EMFILE errors and `universalify` to add promise support to all async methods. It supports both CommonJS and ESM imports. The codebase is well-structured with separate modules for each feature (copy, move, ensure, json, mkdirs, etc.) and comprehensive test coverage. It handles edge cases such as symlinks, permissions, timestamps, cross-device moves, and case-insensitive file systems. The library is actively maintained with frequent releases and supports Node.js 14+.
Higress is a cloud-native, AI-native API gateway built on Istio and Envoy. In production, it operates as a Kubernetes ingress controller, an AI/LLM proxy gateway, and a Wasm plugin host. The system ingests Kubernetes resource definitions (Ingress, Gateway API, custom CRDs like WasmPlugin, Http2Rpc, McpBridge) and translates them into Envoy xDS configurations, managing the full lifecycle of gateway routes, policies, and plugins. It provides a rich set of Wasm plugins (Go, Rust, C++, AssemblyScript) for authentication, rate limiting, request/response transformation, AI proxy (with 15+ LLM providers), semantic caching, RAG, MCP server hosting, and security (WAF, bot detection, IP restriction). The architecture is microservices-oriented: a control plane (Go-based ingress controller) manages Kubernetes resources and pushes config to Envoy data planes; a CLI tool (hgctl) handles installation, plugin development, and debugging; and a plugin release pipeline manages OCI image distribution with provenance verification. External dependencies include Kubernetes (client-go, controller-runtime), Istio (pilot, networking APIs), Envoy (Go filter API), and various AI/vector DB providers (OpenAI, Milvus, Pinecone, etc.).
lf is a mature terminal file manager written in Go. It provides a full TUI built on tcell/v3, with navigation, previews, search/filter, marks/tags, visual mode, and async file operations that delegate actual file mutations to external shell tools. The application follows a client/server architecture: a daemon listens on a Unix socket while multiple client instances can connect, issue remote commands, and maintain per-client state. Entry points are main.go for CLI parsing, client.go/server.go for lifecycle and IPC, app.go/ui.go for the event loop and rendering, and eval.go for command evaluation. Platform-specific code supports Linux, BSD, and Windows, with filesystem watching via fsnotify and disk-free space queries via platform-specific df_*.go files.
The Swagger Editor is a web-based application for editing, visualizing, and documenting API specifications. It supports multiple formats including OpenAPI (2.0/3.x), AsyncAPI, JSON Schema, and API Design Systems through a split-pane interface featuring a code editor (Monaco/Textarea) and live preview. Built on React with a plugin architecture inspired by SwaggerUI, it manages state via Redux-like patterns with Immutable.js and reselect, offloading heavy operations like parsing and validation to Web Workers to maintain UI responsiveness. Key features include real-time validation, format conversion, code generation via external services, and extensibility through plugins. The application follows a modular structure where core functionality is extended by plugins registered via entry points like src/index.tsx and src/App.tsx. Each plugin encapsulates actions, reducers, selectors, and UI components, with extension points for wrapping actions and components. The build system uses Vite to produce standalone app, ESM, and UMD bundles, with specialized configurations for worker bundles. Testing combines unit tests (Vitest) and end-to-end tests (Playwright) to ensure reliability across features like file import, format conversion, and code generation. Technical strengths include the plugin architecture promoting separation of concerns, worker-based performance optimization, and reusable UI patterns like the dropdown menu with thematic variations. Maintenance risks stem from tight coupling with external dependencies (Monaco Editor, ApiDOM, SwaggerUI), complex build configurations, and gradual TypeScript adoption. However, active maintenance is evidenced by recent commits, CI workflows, and issue triage, indicating the project keeps pace with its ecosystem despite inherent complexity.
NeoHtop is a modern, cross-platform system monitor built with Svelte, Rust, and Tauri. It provides real-time monitoring of system processes, CPU usage, memory usage, network I/O, and disk statistics. The application features a beautiful, customizable UI with dark/light theme support, advanced process search and filtering (including regex support), process pinning, and the ability to kill processes. The architecture cleanly separates the Rust backend (which uses the sysinfo crate to gather system information) from the Svelte frontend (which displays the data and handles user interactions), communicating via Tauri's IPC mechanism.