Nextcloud Social is a federated social networking application implemented as a Nextcloud app. It allows each Nextcloud user to become an ActivityPub actor (Person), enabling posting, following, liking, boosting, replying, and direct messaging across the Fediverse. The system is fully compatible with the Mastodon client API, supporting timelines, lists, filters, scheduled posts, polls, stories, collections, trends, and moderation features. The backend is written in PHP, structured with controllers, services, database request builders, and ActivityPub model classes. The frontend is built with Vue 3, Pinia, and Vue Router, providing a responsive single-page application for timelines, profiles, and settings. The app integrates deeply with Nextcloud's dashboard, notifications, search, user migration, and admin settings. Federation is handled via ActivityPub protocols with HTTP signature verification, outbound delivery queues, and WebFinger discovery. The codebase is well-tested with both PHPUnit and Vitest suites, covering unit, integration, and federation wire compatibility tests.
cubeb is a cross-platform C library for low-latency audio playback and recording, originally developed by Mozilla for Firefox. It provides a simple callback-based API and supports a wide range of backends including ALSA, PulseAudio, WASAPI, CoreAudio, OpenSL ES, AAudio, JACK, and others. The library handles device enumeration, resampling (via vendored Speex), channel mixing, and real-time streaming. Its architecture uses a vtable pattern ('cubeb_ops') to abstract backend implementations, and includes several high-quality lock-free data structures. While primarily a production library, it includes extensive test suites and debugging tools like audio dumping. The codebase is actively maintained, with ongoing migrations of some backends to Rust, but retains legacy backends (WinMM, OSS) with limited functionality.
CMasher is a Python library that provides 60+ scientific colormaps for Matplotlib, designed for perceptual uniformity and color-vision-deficiency accessibility. At runtime, importing cmasher registers every colormap into Matplotlib's colormap registry under a `cmr.` prefix, exposing forward, reversed, and for cyclic maps half-shifted variants. The package also ships a CLI (`cmr`), utility functions for combining, sub-selecting, sampling, viewing, and exporting colormaps, plus cross-application exporters for Tableau and R. The colormap definitions themselves are stored as static NumPy arrays, normalized/8-bit/hex text files, JSON `.jscm` files, and generated Python modules, making the project both a functional library and a curated data asset.
Infiltrator.jl is a Julia package that provides an interactive debugging macro, @infiltrate, which acts as a breakpoint with negligible runtime overhead. When triggered, it opens a custom REPL (infil>) allowing developers to inspect local variables, stack frames, module bindings, and evaluate arbitrary expressions. It supports conditional breakpoints, toggling infiltration points on/off, exfiltration of variable values to a store, and integration with Revise.jl for live code updates. The package is designed for development-time debugging and enforces that @infiltrate fails at compile time in package code to prevent accidental commits. It relies heavily on Julia internals (REPL, Core.Compiler, Base.@locals) and maintains compatibility across Julia versions 1.6 through 1.13 via version-adaptive code paths and extensive golden-file test outputs. This is a pure developer tool with no data analysis or research orientation.
This is the LINE Messaging API SDK for Ruby (gem `line-bot-api`), a client library for building LINE bot applications. It provides auto-generated Ruby clients for LINE's various APIs (Messaging API, Webhook, Channel Access Token, Insight, LIFF, Manage Audience, Shop, Module, and Module Attach) from OpenAPI specifications. The library includes a webhook parser with constant-time signature verification, typed model classes with dynamic attribute support, and comprehensive RBS type signatures for static type checking. It is not a data research repository; it is a production-quality SDK maintained by LINE Corporation with active development, CI/CD pipelines, and example Sinatra applications.
SmokeDetector is a headless chatbot that monitors Stack Exchange for spam and abusive content in real time. It connects to the Stack Exchange WebSocket to receive new and edited posts, then runs them through a multi-layered detection engine that checks against extensive blacklists (keywords, websites, usernames, phone numbers, IP ranges, nameservers, ASNs) and applies heuristic rules including DNS lookups, homoglyph detection, and similarity analysis. Detected spam is reported to designated chat rooms on Stack Exchange Chat, where moderators can provide feedback that feeds back into the system via the Metasmoke statistics service. The architecture is event-driven: the main loop in `ws.py` listens for WebSocket events, enqueues posts for scanning via `bodyfetcher.py`, and dispatches results to `spamhandling.py` for chat reporting. A command system in `chatcommands.py` allows operators to manage blacklists, inspect posts, and control the bot through chat messages. Persistent state is stored in pickle files, and the bot integrates with GitHub for automated blacklist pull requests. The detection logic in `findspam.py` is rule-based with over 100 rules registered via a decorator pattern, each with configurable filters for site, reputation, and score. Key reusable components include a generic TTL cache (`metasmoke_cache.py`), an extensible blacklist parser hierarchy (`blacklists.py`), a phone number matching module with homoglyph support (`phone_numbers.py`), and a command registration decorator. The codebase is well-tested with extensive parametrized tests and has CI/CD pipelines. While the core detection file is large and tightly coupled, many supporting modules are cleanly separated and could be extracted for other projects.
GPUReshape is a GPU debugging and instrumentation tool for DirectX 12 and Vulkan APIs. It provides a modular desktop application with backend layers for API interception, shader analysis and transformation capabilities, resource tracking and validation systems, and a plugin-extensible architecture built with Avalonia UI. The system includes automated testing infrastructure and message-passing communication between components.
Figgle is a .NET library for rendering ASCII art banners using FIGlet fonts. It parses standard .flf font files and applies smushing/kerning rules for character merging. The library is delivered as multiple NuGet packages: Figgle (core rendering), Figgle.Fonts (250+ embedded fonts), and Figgle.Generator (Roslyn source generators for compile-time font embedding and text rendering). The repository includes a Blazor WebAssembly interactive demo site, four sample projects, a comprehensive test suite, and a CI/CD pipeline that publishes to NuGet. The codebase demonstrates solid engineering with incremental source generators, string pooling for memory efficiency, and careful parsing of the FIGfont specification. This is a library, not a standalone application.
swift-power-assert is a Swift library that provides a `#assert` macro, delivering detailed diagnostic diagrams for assertion failures. The macro, built on SwiftSyntax, rewrites expressions to capture intermediate values and renders a tree of sub-expression results on failure, including word/line diffs for string comparisons. It supports sync and async evaluation, short-circuiting, and custom operators, aiming to replace multiple assertion APIs (XCTest, Nimble, etc.) with a single, universal assert. The package also includes a `StringWidth` module for accurate Unicode width calculations and a comprehensive test suite (2300+ lines) covering diverse expression types. Additionally, the repository contains an interactive web playground with a Deno backend and Monaco editor, allowing users to test the macro in a browser. The codebase is well-structured, with clean abstractions in the runtime library and plugin, though the macro rewriter is tightly coupled to the capture pattern and the generated Unicode width table is large.
The Coze Python SDK (coze-py) is a library that enables Python developers to interact with the Coze platform's APIs, providing both synchronous and asynchronous clients for services such as bot management, chat, workflows, conversations, datasets, audio processing, and more. It handles authentication (including PAT, OAuth variants), makes HTTP requests via httpx, and processes responses using Pydantic models for validation. The SDK follows a modular architecture with a main client class (`Coze`/`AsyncCoze`) that provides access to service-specific clients via properties. Key reusable components include a pluggable authentication system (supporting TokenAuth, JWTAuth, OAuth flows), a generic pagination system for list operations, streaming response handlers for Server-Sent Events and WebSocket messages, a centralized HTTP requester abstraction, and base classes for WebSocket clients. These components demonstrate non-obvious craftsmanship and could be extracted for use in other API clients. The SDK is actively maintained, as evidenced by recent commits and the deprecation of outdated modules in favor of newer alternatives (e.g., `cozepy.datasets` replacing `cozepy.knowledge`). However, it exhibits medium technical drift due to tight coupling to the Coze API (lacking API version abstraction) and potential susceptibility to changes in authentication flows or WebSocket dependencies. Despite these risks, the codebase maintains high quality through type hints, comprehensive testing, linting, and pre-commit hooks.
ClawDeckX is a desktop/web application that provides a management interface for the OpenClaw AI gateway. It enables users to configure and manage AI agent collaborations, monitor system metrics, install extensions, and access a template marketplace for agent configurations. The application features a Go backend with REST API and WebSocket endpoints, a React/TypeScript frontend, and uses SQLite/PostgreSQL for data storage. Key capabilities include real-time agent room collaboration, configuration management, multi-agent workflow orchestration, notification systems, and cross-platform deployment options.
This repository provides a Java agent that uses the java.lang.instrument API and ASM bytecode manipulation library to instrument every heap allocation in a Java program. It rewrites bytecodes such as NEW, NEWARRAY, ANEWARRAY, MULTIANEWARRAY, and reflection-based Array.newInstance() to insert pre- and post-allocation hooks. A user-defined 'Sampler' callback receives allocation details including count, type descriptor, object reference, and object size. Additionally, it supports constructor-level instrumentation via ConstructorInstrumenter, allowing callbacks on specific class instantiations. The agent is self-contained, handles reentrancy, caches object sizes, and carefully manages bootstrap classloader concerns through a generated Bootstrap class that dynamically appends the agent JAR to the bootclasspath. The build system uses Bazel with custom rules for assembling the agent jar, including ASM relocation via JarJar to avoid classpath conflicts, and stripping of build metadata. The codebase demonstrates expert-level bytecode transformation, robust error handling, and thorough testing covering many edge cases (e.g., multidimensional arrays, lambda allocations, metaspace exhaustion).
Creepyface is a JavaScript library that makes HTML images follow the pointer (mouse/finger/touch) by switching between different angled images. It consists of a core library, React and custom element wrappers, and point provider plugins for dance, firefly, and tilt tracking. The repository also includes a Next.js website that demonstrates the library and allows users to create and share their own creepyfaces. The architecture uses a monorepo with Lerna/Yarn workspaces, featuring a clean separation between the core library logic, UI wrappers, and the demonstration site with its own backend for image processing and storage.
XMap is a high-performance network scanner designed for Internet-wide IPv4 and IPv6 address space scanning. It is a reimplementation and improvement of ZMap, featuring a modular architecture with interchangeable probe modules (ICMP, TCP, UDP, DNS), output modules (CSV, JSON, Redis), and interface identifier (IID) modules for target address generation. The tool uses cyclic groups for efficient, non-sequential address traversal, AES-based validation to prevent response spoofing, and Bloom filters for duplicate packet detection. It is actively used in security research and has been presented at multiple academic conferences. The repository contains significant code duplication among DNS probe modules, which increases maintenance burden.
The PyDev.Debugger (pydevd) is a Python debugger backend designed for IDE integration and remote debugging. It provides core debugging capabilities including breakpoints, stepping, variable inspection, and expression evaluation. The architecture features a client/server model for remote debugging, with in-process tracing via settrace(). Key entry points include pydevd.py (main debugger), pydevd_attach_to_process (live process attachment), and pydevconsole.py (interactive console). The debugger supports multiple protocols (legacy line-based and JSON/DAP for VS Code integration) and employs Cython optimizations with fallbacks to pure Python. It includes extensive test suites covering edge cases like multiprocessing, async, GUI event loops, and framework-specific integrations (Django, Flask). The code demonstrates strong modularity through extension points for custom variable rendering and plugin architecture.
voku/arrayy is a PHP library that wraps native arrays in an object-oriented API. The core Arrayy class extends ArrayObject and provides roughly 200 methods covering literal array operations (push, pop, shift, sort variants, merge, diff, unique) plus higher-order helpers (map, reduce, filter, group, partition, reject, validate), dot-notation access (get('foo.bar')), JSON serialization, and generator-based lazy iteration. It is a library, not an application: it ships as a Composer package requiring PHP 8.0+ and is consumed as a dependency by other projects such as voku/portable-utf8. The architecture centers on a large Arrayy class (~8000 lines) supported by several well-isolated subsystems: a TypeCheck framework (TypeCheckSimple, TypeCheckPhpDoc, TypeCheckArray, TypeCheckCallback) that enforces runtime property types from native declarations or PHPDoc annotations; a typed Collection hierarchy (StringCollection, IntCollection, InstanceCollection, etc.); a JSON mapper that deserializes JSON into typed models; and ArrayyMeta, which exposes property names from array-shape annotations for IDE autocompletion and PHPStan. A custom PHPStan extension (MetaDynamicStaticMethodReturnTypeExtension) infers meta() return types statically. Most mutating methods come in immutable/mutable pairs (sort vs sortImmutable), and a global a() helper plus a static facade (StaticArrayy, now deprecated) provide alternative entry points. Engineering practices are strong: CI runs PHPUnit across PHP 8.0–8.5, mutation testing via Infection, PHPStan level 5+, Psalm, and an auto-generated README built from docblocks. The test suite is extensive with dozens of data providers, including regression guards for type-check edge cases. Known weaknesses include the god-class Arrayy.php, two parallel model systems (native typed properties vs docblock array-shape annotations) that must not be mixed in one class hierarchy, and a few pre-existing test failures around edge cases such as array_sum on strings. Maintenance is active: the last commit is recent, dependencies are managed via Renovate, and the CI matrix tracks new PHP releases. Technical drift is low — the library requires PHP 8.0+, uses current tooling, and has no known security alerts. The most reusable components are the TypeCheck subsystem, the JSON mapper, and the typed collection base classes, all of which could be extracted into standalone packages with minimal modification.
This repository provides a Claude Skill for detecting and removing 'AI slop' from Japanese prose. It consists of a set of guidelines (SKILL.md) and reference files that enumerate problematic phrases, structural patterns, and examples of AI-generated text versus human-revised versions. The skill focuses on restoring human agency, stance, specificity, rhythm, and reduction in LLM-generated Japanese text. It is designed to be used during drafting, editing, or review stages to improve the authenticity of AI-assisted writing.
PanSou Web is a Dockerized web application that provides a unified interface for searching cloud storage resources across multiple platforms including Telegram channels and various cloud storage plugins (Baidu, Alibaba Cloud, etc.). The application features a Vue.js frontend with a Go-based backend service, Nginx reverse proxy, and specialized management interfaces for accounts on services like QQ频道, 观影 (media), 盘链, and 微博. It includes advanced search filtering, link health checking with visibility-based triggering, result export functionality, and real-time system health monitoring. The architecture follows a traditional web application pattern with clear separation between frontend UI and backend API services.
REPENTOGON is a comprehensive modding framework for the game The Binding of Isaac: Repentance. It extends the game's Lua API with hundreds of new functions, provides low-level hooking and assembly patching capabilities, integrates ImGui for developer tools, and adds features like custom item pools, save syncing, virtual room management, and achievement tracking. The architecture is a hybrid of a C++ DLL that injects into the game process and a set of Lua scripts that run in the game's Lua environment. Key entry points include the DLL main (dllmain.cpp) which initializes hooks and patches, and the Lua registration system (LuaInit.cpp) which exposes new classes and callbacks. The framework relies on reverse-engineered game structures, signature scanning, and runtime code modification to achieve deep integration. External dependencies include the game itself, Lua 5.4, ImGui, and several bundled libraries (glad, rapidxml, rapidjson, mINI). The codebase is large and actively maintained, with a strong focus on modder extensibility and bug fixing.
TypeFX.js is a modern typewriter effect library implemented in plain JavaScript (with TypeScript source). It provides a fluent API for simulating typing, deleting, cursor movement, and text selection in DOM elements. The library is designed to be framework-agnostic and can be used in vanilla JavaScript, React, Vue, or any other web environment that supports the DOM. The core of the library is the `TypeFX` class, which manages an internal queue of actions to sequence asynchronous operations. It ensures only one instance per DOM element using a WeakMap and supports chaining of methods like `.type()`, `.wait()`, `.delete()`, etc. The library also allows customization of typing speed, caret appearance, and entrance/exit animations via the Web Animations API. The library is distributed as ES modules, CommonJS, and UMD formats via Rollup, with no runtime dependencies. It includes a comprehensive test suite that uses a custom fake DOM implementation to run tests in Node.js, demonstrating good testing practices for DOM-dependent code.