This is the working repository of the W3C CSS Houdini Task Force: a collection of editor's drafts (specifications) for browser APIs that expose CSS internals to JavaScript. The content is written in Bikeshed (.bs) format and processed by a Python build pipeline (bin/build-markdown.py, bin/build-index.py, Makefiles, GitHub Actions) into the HTML specs served via GitHub Pages. The repository contains formal, normative algorithm definitions for the CSS Paint API (registerPaint), CSS Layout API (registerLayout), CSS Animation Worklet (registerAnimator), CSS Properties & Values API, CSS Typed OM, Font Metrics API, Box Tree API, and Worklets. It is not a runtime application or a data pipeline — it is documentation-as-code with build automation and small runnable examples — but it is classified as "application" because its dominant content is executable artifacts (worklet demo code, CI scripts, build tooling) rather than data assets. The highest-craft content is in the spec sources: the CSS Typed OM draft defines a complete, self-contained algebra for CSS numeric values (base types, percent hints, sum values, unit conversion, canonical units) plus a reify/serialize pair that converts between internal CSS representations and typed JavaScript objects. The CSS Layout API draft specifies a work-queue processing model, global scope selection, and structured serialization for worklet data — all reusable algorithmic patterns for browser-engine implementers and polyfill authors. The included paint-worklet demos (circle, arc, chat) are isolated, copy-pasteable examples of the registerPaint contract. Maintenance is active: the last commit is recent, the Typed OM changes section references live GitHub issues/PRs, and the CI installs pinned dependencies. However, there is notable internal drift: css-parser-api has been moved to WICG (its Overview.bs is blank), worklets/Overview.bs now redirects to the HTML Standard, scroll-customization-api remains an explainer without a formal spec, and several Typed OM reification entries are explicitly empty stubs or marked with open issue markers. The 2018 issue-list artifacts and README_old.md files add historical clutter. For engineers, the practical value is threefold: (1) reference implementations of the Houdini API surface for anyone building polyfills, browser features, or CSS tooling; (2) a clean, reusable Bikeshed-spec build/deploy pipeline (Python scripts + GitHub Action) that can be extracted to any W3C-style spec repo; and (3) minimal worklet starter examples. It is not code you deploy — it is a standards workshop, and the quality bar is standards-writing rigor rather than software architecture.
Dynacat is a self-hosted, widget-based dashboard application written in Go. It serves as a fork of Glance with a focus on dynamic content reloading and easy integration of external services. The system allows users to define pages composed of columns and widgets via a YAML configuration file, which can be edited live through a built-in web UI editor. Widgets fetch data from a wide range of sources including RSS/Atom feeds, Reddit, Hacker News, YouTube, Twitch, weather APIs (Open-Meteo), stock markets (Yahoo Finance), Docker containers, system statistics, media servers (Plex, Jellyfin, Emby), torrent clients, DNS services (Pi-hole, AdGuard), and custom JSON APIs. The architecture is a monolithic Go web server that serves HTML templates, static assets, and a RESTful API for page/widget content, authentication, and editor operations. Dynamic updates are delivered via Server-Sent Events (SSE) and client-side polling, with per-widget configurable intervals. The application includes a full authentication system supporting password-based login with bcrypt and OIDC, session management, and optional editor login requirements. External dependencies include a Go HTTP server, YAML parsing, RSS/Atom feed parsing, OIDC client, and various system information libraries. The project is packaged for Docker deployment and includes a Windows installer via Inno Setup.
Codiff is a desktop code review tool (Electron + React) that visualizes Git diffs, supports AI-generated narrative walkthroughs, and integrates with GitHub/GitLab pull requests. It also provides a web sharing service for walkthroughs and plans, allowing users to share review snapshots publicly. The architecture is a monorepo with three packages: `core` (React UI library), `service` (Cloudflare Workers sharing API), and `web` (Cloudflare Workers frontend for shared content). The Electron main process handles Git state reading, AI agent orchestration, configuration, and window management, while the renderer uses React with custom hooks for review state, comments, walkthrough navigation, and diff search. Key entry points include `bin/codiff.js` (CLI), `electron/main.cjs` (Electron main), `core/index.tsx` (renderer), and `web/src/App.tsx` (web app). Data flows: Git diff data is parsed in `electron/git-state/` and sent to the renderer via IPC for display. AI walkthroughs are generated by calling external agent CLIs (Codex, Claude, OpenCode, Pi) from the main process, with output parsed and cached locally. Sharing involves uploading walkthrough/plan manifests to a Cloudflare Workers API backed by D1 and R2. External dependencies include Git, `gh`/`glab` CLIs, multiple AI agent CLIs, and Cloudflare infrastructure. The codebase is well-tested with extensive unit and integration tests, and includes an evaluation framework for walkthrough quality.
Irodori-TTS is a state-of-the-art Japanese text-to-speech system built on rectified flow diffusion over DACVAE audio latents. It provides a complete training and inference stack: `train.py` supports full fine-tuning, LoRA, speaker inversion, and MeanFlow distillation with distributed training and WSD scheduling; `infer.py` offers a rich CLI with CFG, Sway Sampling, duration scaling, and watermarking; `gradio_app.py` and `gradio_app_voicedesign.py` expose interactive UIs for reference-based cloning and caption-conditioned voice design. The architecture is modular (`irodori_tts` package) with attention dispatch (FA3/SDPA), a hybrid Muon+AdamW optimizer, codec abstraction, and caching-friendly `InferenceRuntime`. While highly engineered for production use (INT4/INT8 quantization, safetensors, HuggingFace Hub integration), it remains a research-oriented codebase with experimental sampling algorithms and many YAML configs for different model sizes/versions. The code is clean and well-factored, though `train.py` is a large monolith and external dependencies (DACVAE, silentcipher) are pinned to specific commits, creating ecosystem fragility.
Commonly is an open-source multi-agent collaboration platform where humans and AI agents work together in shared workspaces called 'pods'. The system provides real-time messaging, task management, agent runtime (native, hosted, or bring-your-own), marketplace for agent skills, and integrations with external chat platforms like Discord, Slack, Telegram, and GroupMe. The architecture is a full-stack monolith with separate external agent bridge services and a Cloudflare Workers-based agent runtime. The backend (Node.js/Express) uses a dual-database design (MongoDB for primary data, PostgreSQL for messages/tasks) with automatic sync. The frontend is a React SPA with a v2 design system. The CLI allows local agents to participate via device-code auth and polling. The MCP server provides standard tools for agents to interact with the platform. The codebase is well-structured with extensive test coverage (unit, integration, E2E), Architecture Decision Records (ADRs), and reusable packages for types, integration SDK, and MCP tools. Notable craftsmanship includes pluggable storage drivers, deterministic agent wake targeting, and a test utility that replicates the production PostgreSQL schema to catch DDL drift.
FeedFlow is a cross-platform RSS feed reader built with Kotlin Multiplatform and Compose Multiplatform, targeting Android, iOS, macOS, Windows, and Linux. It provides a rich reading experience with customizable layouts, reader mode with article extraction, offline content prefetching, and OPML/CSV import/export. The application emphasizes reliability through extensive unit testing, Maestro-based E2E tests for both mobile platforms, and a sophisticated cloud synchronization system supporting Dropbox, Google Drive, iCloud, FreshRSS, Miniflux, Feedbin, and BazQux. The architecture follows MVVM with clean separation of concerns (domain, data, presentation layers), uses Koin for dependency injection, SQLDelight for local persistence, and Ktor for networking. Platform-specific adaptations exist for background sync (Android WorkManager, iOS background tasks), widget support, and UI components (Compose Multiplatform for Android/Desktop, SwiftUI for iOS). The codebase demonstrates high craftsmanship with modular design, reusable abstractions (DataResult, content direction detection, image extraction, HTTP caching), and thorough test coverage including cloud sync conflict scenarios.
This repository contains a minimal coding agent designed to work with local Ollama models. The agent operates in a loop, processing user requests by inspecting and modifying the workspace through a set of structured tools (file operations, shell commands, etc.). It implements six core components: live repo context collection, prompt shaping with cache reuse, structured tools with validation and permissions, context reduction and output management, transcript and memory persistence, and bounded delegation to subagents. The agent is implemented in a single Python file (`mini_coding_agent.py`) and is intended to be run via a CLI entry point. It requires an Ollama server running with a compatible model (default: qwen3.5:4b). The code is clean, well-structured, and demonstrates thoughtful agent design patterns, making it a useful reference for building similar agents.
dpt-shell is an Android application protection tool that implements a 'method extraction shell' for dex files. It consists of two main components: a Java-based processor (dpt.jar) that transforms Android APK/AAB packages, and a native C++ shell library that runs inside the protected app at runtime. The processor extracts bytecode from all dex methods, encrypts it with RC4, and replaces the original instructions with minimal return stubs. The encrypted bytecode and a configuration blob are stored as assets in the package. At runtime, the shell hooks into Android's class loading mechanism (via Dobby/bhook) to intercept DefineClass or LoadClass calls, decrypts the original bytecode on-the-fly, and writes it back into the dex memory region before the class is fully initialized. The tool also includes anti-tamper features such as Frida detection, libc .text CRC verification, debugger detection, and optional app signature verification. The processor supports both APK and AAB formats, handles multi-dex packages, and can optionally split classes into keep/extract sets for performance. The shell is compatible with Android 5.0+ and adapts to different Android API levels (21, 28, 35+).
This is a document redaction and anonymization platform designed for processing unstructured data (documents, images, PDFs) and structured data (CSV, databases) to detect and redact sensitive information like PII, PHI, and financial data. The system features a React/TypeScript frontend with a Python/FastAPI backend, utilizing AI models for NER (HaS Text), OCR (PaddleOCR-VL), and visual detection (LocateAnything). It provides both single-file processing via a playground interface and batch processing workflows with review/approval steps. The platform includes role-based access control, audit logging, configurable presets for different industries, and structured data handling capabilities. Deployment is containerized with Docker and supports GPU acceleration for ML models.
This repository is a comprehensively governed, production-grade library of 115+ prompt templates, meta-prompt generators, workshop guides, and structured routines for AI-assisted product management. It is not a deployed software application but rather a content methodology repository with application-like engineering discipline: standalone prompt contracts, coupling levels, CI-validated metadata, deterministic catalog generation, and an explicit coupling remediation plan. The library covers the full product management lifecycle—discovery, strategy, requirements, competitive intelligence, end-of-life, storytelling, and team facilitation—using three defined interaction modes (facilitation, co-construction, autonomous investigation). Notable sub-collections include an eight-discipline market intelligence framework (OSINT, FININT, GEOINT, etc.) with an all-source fusion prompt, a complete product sunset (EOL) workflow, and a TAM-SAM-SOM market sizing Langflow pipeline. The repo exhibits hybrid character: while primarily a content asset, it includes reusable Python scripts for validation and catalog generation, a GitHub Actions CI pipeline, and follows software engineering best practices such as versioning, changelogs, and architectural decision records.
This repository is a curated 'awesome list' of password cracking tools, research, and resources — not a software application. The primary artifact is a single, comprehensive README.md that catalogs ~150 tools and resources across 15+ categories: hashcat automation/distributed cracking/rules, John the Ripper tooling, cloud-based cracking (AWS/Colab), wordlist generators and analyzers, hash conversion utilities, ML/AI password guessing models, academic papers (2009-2026), and notable researchers in the field. The list is alphabetically sorted, CC0-licensed, and maintained by a human curator who explicitly rejects AI-generated contributions. The repo's engineering value lies in its community governance infrastructure. A GitHub Actions workflow (pr-quality.yaml) uses peakoss/anti-slop to automatically detect and close AI-generated or spam PRs, enforcing account age, profile completeness, PR size limits, and maintainer-can-modify permissions. A second workflow runs awesome-lint to enforce list formatting standards. The PR template requires AI self-disclosure via a magic string. This governance stack is a genuinely reusable pattern for any community-curated repository facing AI slop. The content is current (papers through 2026) and the repo is actively maintained with zero open issues. While it contains no application code, it serves as a high-value reference index for security researchers, penetration testers, and anyone working on password recovery or authentication security. The hybrid nature: it's a curated data resource (the list itself) wrapped in application-grade CI/CD governance.
jvms is a Windows-native JDK version manager written in Go. It installs, switches, lists, and removes multiple JDK versions using symlinks and environment variable manipulation (JAVA_HOME, PATH). The system fetches available JDK distributions from multiple sources: an embedded index (GitHub releases), Azul Zulu API, and Adoptium API. It caches the version catalog and supports a progress bar during downloads. The CLI provides commands for installing (`install`), switching (`switch`, `use`), listing (`list`, `rls`), configuring (`config`, `proxy`), and an interactive TUI (`tui`) built with Bubble Tea. The architecture is layered: a CLI entry point, a platform abstraction layer (Provider interface) that delegates to a native Windows implementation using syscalls for admin checks and symlink creation, and a JDK provider layer for fetching version lists. The project is well-tested with unit and integration tests, uses modern Go (1.24), and has no external software dependencies other than the JDK archives themselves.
ExprTk is a header-only C++ library for runtime mathematical expression parsing and evaluation. It provides a complete system for defining mathematical expressions as strings, compiling them into an internal AST representation, and evaluating them with variable values. The library supports scalar, vector, and string types, arithmetic operations, trigonometric functions, logarithms, control structures (if, for, while, switch), user-defined functions, and assignment operations within expressions. It employs sophisticated parsing techniques including constant folding, strength reduction optimizations, and runtime safety checks for vector bounds and loop execution time. The architecture consists of three main components: symbol table (for variables/constants/functions), expression (holding the parsed AST), and parser (compiling expression strings).
Cocoa-Way is a macOS-native Wayland compositor that runs Linux GUI applications inside container runtimes (Apple Container, Docker, OrbStack, or via SSH/Waypipe) and renders them to macOS windows using Metal. The core architecture consists of a Rust binary that serves as both a desktop compositor (single window with tiled layout) and a rootless mode that maps each xdg-toplevel to a native macOS window. It features bidirectional clipboard relay (text and PNG, up to 64 MiB), CoreAudio forwarding, a control API over Unix sockets, and an optional MCP server for AI-assisted diagnostics and onboarding. The project demonstrates high craftsmanship in its Metal renderer with texture caching and damage-coalescing, as well as in its container session management, which handles multiple runtime backends and complex lifecycle orchestration. The codebase is well-structured but contains a few monolithic files (e.g., main.rs, container_mode.rs) that handle a large amount of state and UI logic.
This repository provides a complete, production-ready solution for converting LoctekMotion/FlexiSpot standing desks into smart, Home Assistant-integrated devices. The core of the project is a set of ESPHome YAML packages and custom ESPHome components that communicate with the desk controller over a serial (UART) interface via an RJ45 connection. The firmware decodes the desk's proprietary 7-segment display protocol to report height as a sensor, and sends commands (up, down, presets, memory, alarm, child lock) to control the desk. It supports both direct connection (using a spare RJ45 port) and pass-through configurations (intercepting the keypad line). The repository includes well-structured, parameterized YAML configurations for ESP32 and ESP8266, custom C++ sensor components for height and keypad command decoding, and Python code generation stubs for ESPHome. Archived Arduino sketches and a Raspberry Pi Python script are also provided for alternative implementations. The project is actively maintained, uses modern tooling (uv, ruff, pre-commit, CI), and demonstrates strong embedded systems and protocol reverse-engineering skills.
PikaTorrent is a cross-platform BitTorrent client built with Flutter, supporting Windows, macOS, Linux, Android, and iOS. It provides a modern, user-friendly interface for downloading and streaming torrents, with features like sequential downloading, media playback with subtitle/audio track selection, torrent tagging and filtering, and platform-specific integrations (system tray, background service, file association). The application follows a clean architecture with an engine abstraction layer (currently backed by the Transmission library via flutter_libtransmission), provider-based state management (AppModel, SessionModel, TorrentsModel), and separate HTTP servers for streaming content and subtitles. The codebase is generally well-organized, though it contains some hardcoded values and minor code smells. The project is actively maintained with a full CI/CD pipeline and multi-platform release automation.
Linkook is a Python CLI tool for OSINT-driven discovery of linked social media accounts and associated emails across multiple platforms. It takes a single username as input, scans a configurable set of websites (defined in a provider.json file), and recursively extracts linked accounts, usernames, and emails from discovered profiles. The tool supports breach checking via HudsonRock's database or Have I Been Pwned, and can export results to a Neo4j-compatible JSON format for graph visualization. The architecture is modular: a Provider class handles URL templates and regex extraction, a SiteScanner performs HTTP requests and keyword-based existence checks, and a ScannerManager manages concurrent scanning via a thread pool with a queue. The code is well-structured, includes unit tests, and demonstrates solid engineering practices with clean separation of concerns, error handling, and logging.
Cog is a native macOS audio player with an exceptionally broad format support, uniquely specializing in video-game music emulation and obscure audio codec playback. Its architecture is built on a clean, modular plugin system (CogDecoder, CogSource, CogContainer protocols) that integrates dozens of vendored emulator cores (vgmstream, GME, OpenMPT, lazyusf) and general decoders (FFmpeg, TagLib). The app features a composable DSP chain for real-time effects (equalizer, HRTF binaural, tempo/pitch shifting), high-performance threading primitives (CogSemaphore), and a modern Model Context Protocol (MCP) server for remote control by AI agents. This is a classic case of a well-crafted application core coupled with a massive, critical dependency on vendored third-party code; the plugin protocols, DSP nodes, synchronization primitives, and MCP bridge are high-quality, reusable components, while the collection of emulator cores introduces significant licensing and maintenance complexity.
MCPM (Model Context Protocol Manager) is a Python CLI tool for discovering, installing, configuring, running, and sharing MCP (Model Context Protocol) servers. It acts as a package manager for the MCP ecosystem, allowing users to search a curated registry of 160+ servers, install them with environment variable configuration, run them directly via stdio or HTTP, and integrate them with 15+ MCP client applications (Claude Desktop, Cursor, Windsurf, etc.). The tool also supports virtual profiles for organizing servers into groups, public sharing via tunnels, usage analytics, and automatic migration from v1 configurations. Architecturally, MCPM is a modular Click-based CLI application with separate command modules, a client manager abstraction for multi-platform config management, a FastMCP-based proxy for server aggregation and execution, and a monitoring subsystem for usage tracking. It relies on external registries (mcpm.sh API) and package managers (npm, uvx, pip) for server distribution. The repository also includes a large curated registry of MCP server manifests (mcp-registry/servers/*.json) with structured metadata, which serves as both the data backbone for the CLI and a standalone catalog for the MCP ecosystem. While primarily an application, the repository has a hybrid nature due to the extensive server registry data and the scripts for generating, validating, and categorizing server manifests. The registry is a significant data asset that could be used independently of the CLI tool.
This repository contains a collection of scripts and configurations for merging and generating proxy subscriptions, primarily for Clash and Sing-box. It aggregates various proxy nodes from different sources and compiles them into a unified subscription.