This repository contains implementations of a 'swapview' program that displays Linux process swap usage in many different programming languages. Each implementation reads from the /proc filesystem to gather swap information for all processes and outputs a formatted table sorted by swap usage. The project includes a top-level Makefile to build all implementations, benchmarking tools (bench.py and a Rust-based benchmarker) to compare performance across languages, and result files showing historical performance data. The code serves as both a practical utility for monitoring swap usage and a comparative study of language performance and idioms.
This repository is a curated skill library for data analysis workflows, designed to be consumed by AI agents (Claude Code, Codex). It contains 31 skills organized into 6 categories: data quality validation, documentation/knowledge management, data analysis/investigation, data storytelling/visualization, stakeholder communication, and workflow optimization. Each skill is defined by a SKILL.md file with YAML frontmatter, a step-by-step process, required inputs/outputs, and optional scripts, reference materials, and asset templates. The scripts are standalone Python CLIs that generate synthetic data for demo purposes and can be adapted to real datasets. The repo is not a deployable application or a data pipeline; it is a structured knowledge base and toolset for performing data analysis tasks programmatically. It covers common analytical patterns such as null counting, duplicate detection, cohort retention, funnel conversion, A/B testing, time series anomaly detection, metric calculation, and more. The codebase is well-organized and follows consistent conventions, but shows signs of staleness (future dates in README and LICENSE, no recent activity). Dependencies are not pinned, and no environment definitions are provided, limiting reproducibility without manual setup.
This repository is a Spanish localization data package for the mobile game Umamusume: Pretty Derby, designed to be used with the Hachimi modding tool. It contains over 11,000 JSON files under `localized_data/` that provide translated dialogue for story scenes, home screen interactions, race commentary, and song lyrics. The data follows a consistent schema (`no_wrap`, `text_block_list` with `name`, `text`, optional `choice_data_list` and `color_text_info_list`), making it easy to parse and integrate. The only executable code is `gen_index.py`, a utility that walks the git tree and generates a JSON index with Blake3 hashes for file integrity verification, used by Hachimi to fetch updates. The repository also includes configuration files (`config.json`, `config_android.json`) for the modding tool and a GitHub Actions workflow (`release.yml`) that automatically builds and deploys the index on pushes to main. While not a traditional data research project, the repo represents a well-organized, version-controlled dataset for game localization, with a clear pipeline for distribution. The translation quality appears consistent, though the large number of files and presence of some duplicate entries suggest manual maintenance overhead. The `gen_index.py` script is a self-contained, reusable component for generating file indexes with cryptographic hashes, applicable to any mod or asset pack project.
This repository is a collection of Home Assistant blueprints (YAML automation and script templates) that enable voice-controlled music playback via the Music Assistant integration. It provides three distinct options: a fully local intent-based automation using custom conversation triggers, an LLM-enhanced automation that leverages an external LLM conversation agent to parse natural language queries, and an LLM script that can be used as a tool by LLM conversation agents for more flexible music requests. The blueprints are well-structured with multi-language support (English, Dutch, French, German, Hungarian, Italian, Portuguese, Slovak, Spanish, Finnish) and demonstrate advanced use of Home Assistant's conversation triggers, Jinja2 templating, and integration with Music Assistant's play_media service. The repository is community-driven and actively maintained, with detailed documentation and changelogs. While tightly coupled to Home Assistant and Music Assistant, the blueprints exhibit good craftsmanship in handling target resolution, shuffle logic, and LLM prompt engineering.
Open-IG is an open-source clone of the classic space strategy game Imperium Galactica, implemented in Java. It provides a full-featured single-player experience including empire management, space and ground combat, diplomacy, research, colonization, and a campaign with scripted missions. The game loads all content from XML data files and image/audio assets, supporting multiple languages (English, German, French, Spanish, Hungarian, Russian). The architecture is a monolithic Java application with a custom UI framework built on top of Java's graphics capabilities. The codebase is organized into clear modules: model (game state and data structures), mechanics (simulation and AI logic), screen (rendering and UI screens), ui (reusable UI components), and utils (general-purpose utilities). The game uses a component-based screen system where each major view (starmap, colony, spacewar, etc.) is a separate class. Audio playback includes a built-in OGG decoder (jorbis/jogg) bundled in the source. Key entry points include Startup.java (main game), Launcher.java (update management), MapEditor.java (map editing tool), and CampaignEditor.java (campaign scripting editor). The game relies on minimal external dependencies—primarily the bundled OGG libraries and standard Java—and uses Gradle for build automation. The project also includes CI workflows for entropy scanning and building. While the codebase is substantial and well-organized, it is a hobby project with a large number of open issues (164) and occasional rough edges. The game is fully playable and has been under active development for many years, with regular releases and asset updates.
This repository implements the INP-Former model for anomaly detection in industrial inspection tasks. The system extracts Intrinsic Normal Prototypes (INPs) directly from test images using a DINOv2 vision transformer encoder, followed by an INP extractor and decoder to reconstruct normal regions. Reconstruction errors serve as anomaly scores. The repository provides training scripts for various settings (single-class, multi-class, few-shot, zero-shot, super-multi-class), a Gradio-based zero-shot application for interactive inference, ONNX conversion and inference tools, and a competition submission kit. It achieves state-of-the-art performance on standard benchmarks like MVTec-AD, VisA, and Real-IAD. The architecture is modular, separating the core model, dataset handling, utilities, and training logic, though training scripts show some duplication across different settings.
ChatClaw is a desktop AI assistant application built with Wails v3 (Go backend + Vue 3 frontend) that provides a local-first, multi-platform AI agent experience. It integrates with multiple messaging platforms (WeChat, QQ, DingTalk, Feishu, WeCom, WhatsApp) through gateway adapters and manages AI agents using the CloudWeGo Eino framework. The application features a knowledge base with full-text search (FTS5) and vector embeddings (sqlite-vec), document processing pipeline (parsing, splitting, RAPTOR hierarchical summarization), scheduled tasks with cron execution, a skill marketplace, MCP tool support, and native desktop capabilities like window snapping, floating ball, and text selection popups. It also bundles an OpenClaw Node.js runtime for advanced agent workflows. The frontend is Vue 3 with TypeScript, Pinia, and shadcn-vue UI components. The architecture is a monolith with service-oriented backend and multiple WebView windows. Note: The repo shows signs of hybridity as it includes substantial data/research components (RAPTOR, embeddings, document processing) but these serve the application's core functionality.
This repository implements a Field-Programmable Gate Array (FPGA) based emulator for Nintendo Game Boy and Game Boy Color systems, specifically targeting the Analogue Pocket handheld console. The design consists of hardware description language (Verilog/VHDL) modules that replicate the original hardware components including a Z80-compatible CPU core (T80), memory controllers, video display subsystem, four-channel audio processing unit, input handling, cartridge interface with various Memory Bank Controller (MBC) implementations, save state functionality, and real-time clock support. The architecture follows a modular approach with clear separation of concerns between subsystems, interconnected through well-defined interfaces. The project demonstrates significant effort in achieving hardware-level accuracy while incorporating modern features like save states, fast forwarding, and custom palettes. While the codebase shows signs of active maintenance and ongoing development, it remains tightly coupled to the target FPGA platform (Cyclone V) and associated Intel/Altera toolchain, which limits immediate portability to other hardware platforms.
Pinkfish is a Python library for backtesting rule-based trading strategies on stocks and ETFs. It provides a clean, modular API for fetching historical price data (via Yahoo Finance with optional caching), computing custom technical indicators (SMA, EMA, CROSSOVER, MOMENTUM, VOLATILITY), simulating trades with configurable fills and margin, and generating comprehensive performance statistics (Sharpe, drawdown, profit factor, etc.). The library supports single-symbol strategies as well as multi-asset portfolio backtesting with rebalancing and position sizing. The repository includes over 30 example Jupyter notebooks and Python scripts that demonstrate canonical strategy patterns (momentum, mean reversion, sector rotation, golden cross) and parameter optimization workflows. While the core library is well-structured and documented with pdoc3-generated API docs, the codebase shows signs of technical drift: a deprecated method (`add_technical_indicator`), a static stock market calendar file that must be manually regenerated, and some example notebooks containing future-dated execution outputs that suggest stale or simulated data. The library is not a live trading platform; it is designed for research and signal generation with daily end-of-day data. Despite these minor issues, pinkfish offers a solid, lightweight alternative to heavier backtesting frameworks like Zipline or Backtrader, with particular strength in the clarity of its trade log and statistics modules.
Outpacket is a comprehensive cheatsheet/reference guide that maps traditional impacket penetration testing workflows to modern alternative tools like gopacket, Titanis, NetExec, and others. It serves as a static documentation resource for security professionals working with Windows environments, particularly Active Directory attacks. The repository contains only a single README.md file organized into sections covering authentication, remote execution, Kerberos operations, SMB/file operations, credential dumping, enumeration, AD/LDAP operations, auth coercion, certificate attacks, and exotic credential harvesting techniques. Each section provides command examples for multiple tools alongside explanatory notes about tool-specific behaviors and limitations.
TouchTerrain is a web application and standalone tool that converts digital elevation models (DEMs) into 3D-printable terrain models (STL/OBJ). It uses Google Earth Engine as the primary DEM source, with support for local GeoTIFF files. The architecture includes a Flask web server with a frontend using Google Maps and Three.js for preview, a standalone Python script for batch processing, and Jupyter notebooks for interactive use. The core processing pipeline fetches DEM data, resamples it, tiles it, generates mesh geometry with optional walls and bottom, and bundles the output as a ZIP file. The repository also includes geospatial utilities (coordinate conversion, KML parsing, GPX path embossing) and raster cleaning functions. While the codebase is functional and well-documented, it shows signs of technical drift: multiprocessing is broken, JavaScript libraries are outdated (Three.js r71), and there is commented-out code. The project is actively maintained with recent commits and issue triage.
This repository defines the quantized-mesh-1.0 terrain format, a specification for encoding and streaming terrain tiles in a multi-resolution quadtree pyramid. It includes detailed documentation of the binary tile structure (header, vertex data, index data, edge indices, and extensions) and the JSON manifest format (layer.json) with accompanying JSON schemas for validation. The format is used by CesiumJS for 3D terrain rendering and enables efficient sharing of terrain data. While the repository does not contain processing code, it provides a complete and reusable specification for producers and consumers of quantized-mesh tiles, including the schemas for layer manifests and availability rectangles.
This repository is a collection of C++ sample programs for deploying deep learning models on AXERA AI SoCs (NPU chips). It provides ready-to-run inference examples for a wide range of computer vision tasks including object detection (YOLOv5/6/7/8/9/10/11/26, YOLOX, YOLO-World, PPYOLOE+, RT-DETR, SCRFD), instance segmentation, oriented object detection (OBB), pose estimation, depth estimation, semantic segmentation, stereo matching, and more. Each example is a standalone command-line executable that loads a pre-compiled .axmodel, runs inference via the AX_ENGINE API, post-processes the outputs, and saves a result image. The code is organized per target chip (ax650, ax637, ax620e, ax615) with near-identical copies of examples across platforms, differing only in system initialization and minor chip-specific logic. The architecture is not a library or framework but a set of reference implementations demonstrating the integration of AXERA's NPU SDK. The primary data flow is: load image → preprocess (letterbox resize, color conversion) → push to engine → run synchronous inference → decode model outputs (e.g., anchor-based proposals, DFL, NMS) → draw bounding boxes/keypoints/masks → save output. External dependencies include the AX_ENGINE runtime, OpenCV for image processing, and standard C++ libraries. The build system uses CMake with per-chip toolchain files and GitHub Actions CI for cross-compilation verification. While the code is functional and covers a broad model zoo, it exhibits significant duplication across chip directories and hardcoded configuration (thresholds, image sizes, class names). The monolithic detection.hpp (~3500 lines) bundles many model-specific post-processing functions, increasing maintenance burden. There are no automated tests, and manual memory management is prevalent. Despite these quality issues, the repository serves its purpose as a practical reference for developers integrating AXERA hardware, and it stays current with recent model releases (YOLOv13, YOLO26, Depth Anything V2).
This repository is primarily an educational resource for teaching data science and machine learning concepts. It contains a extensive collection of Jupyter notebooks, Python scripts, and supporting materials covering topics from basic statistics and pandas to advanced deep learning, NLP, and LLMs. The content is organized as tutorials and examples rather than a cohesive application, with numerous datasets included for hands-on learning. The repository appears to be actively maintained with recent updates, suggesting efforts to keep the educational content current with evolving technologies.
This repository is a cheat sheet and extension for the Xonsh shell. It provides comprehensive documentation in README.md covering Xonsh installation, basics, operators, environment variables, aliases, path strings, globbing, macros, tab completion, and more. Additionally, it includes a xontrib (plugin) that adds a 'cheatsheet' command to Xonsh for opening the documentation in a web browser, and an example script demonstrating how to create Xonsh CLI tools with argument parsing and tab completion. The project is packaged as a Python package for distribution via PyPI.
ACT.Hojoring is a mature Windows plugin suite for Advanced Combat Tracker (ACT) tailored to Final Fantasy XIV. It bundles three main plugins: SpecialSpellTimer (spell/cooldown timers, trigger matching, and raid timeline overlays), UltraScouter (target HP/distance/casting/enmity/radar overlays), and TTSYukkuri (multi-engine text-to-speech with Discord voice relay). The code is almost entirely C#/.NET Framework with WPF overlays, Prism MVVM, XML-serialized configuration, and a shared infrastructure library called FFXIV.Framework. Entry points are ACT plugin implementations (IActPluginV1.InitPlugin) that initialize workers, load settings, register config tabs, and start transparent click-through overlay windows.
This repository implements the continuous integration infrastructure for the Bazel project. It manages Buildkite pipelines, GCP compute instances, and Docker images to run CI for Bazel and its ecosystem of rules. The codebase includes a dashboard for CI status and GitHub issue tracking, a metrics service that collects build statistics to BigQuery and Cloud SQL, a Rust agent for artifact upload, and GitHub Actions for automating Bazel Central Registry PR review and release cherry-picking. While primarily an application-focused infrastructure repo, it contains data pipeline components for metrics processing. The architecture is a collection of loosely coupled scripts and services, with some reusable components like the cached Buildkite client and the BEP artifact uploader.
discord-haskell is a mature Haskell library for building Discord bots, rather than a standalone application. Its primary entry point is `runDiscord`, which connects to both Discord's REST API and WebSocket gateway, then dispatches typed gateway events to a user-supplied handler. Internally the library runs several cooperating threads: a gateway websocket loop with reconnect/resume handling, a cache thread, a rate-limit-aware REST request queue, and a logger thread. Communication between threads is done through `Chan`s and `MVar`s, and user code runs in a `ReaderT DiscordHandle IO` monad (`DiscordHandler`). The public API is built around large ADTs: an `Event` type for gateway dispatches, GADT request types such as `ChannelRequest` and `GuildRequest` that compile to HTTP calls via the `req` library, and a substantial collection of Discord object types with `FromJSON`/`ToJSON` instances. It supports interactions and slash commands, message components, threads, scheduled events, auto moderation, webhooks, emoji and sticker uploads, voice-adjacent REST calls, and more. Re-export modules such as `Discord`, `Discord.Types`, `Discord.Requests`, and `Discord.Interactions` keep the user-facing surface reasonably clean while `Discord.Internal.*` modules remain exposed for power users. Code quality is solid but not exemplary. The library has no test suite; CI only verifies that it builds across a matrix of GHC versions. There are several copy-paste bugs or small mistakes in route/serialization logic (for example `GetGuildWidget` points at the integrations endpoint, `GroupDMAddRecipient` duplicates a path segment, and `ScheduledEventExternal` has a mismatched `entity_type`), and the cache is explicitly documented as work in progress. Dependency bounds are kept reasonably current, including GHC 8.10 through 9.14 and aeson 2.x, and the changelog shows steady feature additions, so this is a maintained library with occasional rough edges rather than abandoned code.
I‑Simpa is a mature, open‑source desktop application for 3D numerical sound propagation modelling, designed for scientific acoustic simulations. The system provides a full GUI (built with wxWidgets and OpenGL) for defining acoustic scenes (sources, receivers, materials, meshes), running multiple calculation cores (particle tracing SPPS, classical theory TCR, and experimental TLM), and post‑processing results via point/surface receivers, impulse responses, and sound maps. It features a tree‑based data model with XML persistence, a Python scripting layer for automation and custom tools, and supports industry‑standard file formats (STL, PLY, GABE binary arrays). The codebase is predominantly C++ with a Boost.Python bridge, and is actively maintained by the Environmental Acoustic Research unit at Université Gustave‑Eiffel. The architecture follows a classic monolith pattern with clear separation: a core calculation library (`src/spps/`, `src/ctr/`), a 3D rendering engine (`src/isimpa/3dengine/`), a GUI layer (`src/isimpa/IHM/`), and a data manager with element/property tree. Python scripts in `SystemScript/` extend the UI through a plugin mechanism. While the project is functionally complete and validated against benchmarks, it exhibits moderate technical drift: bundled MathJax 2.7.5 (2018) for documentation, some French comments and variable names, and a few Python 2 remnants. Despite this, the component design—especially the octree spatial index, GABE binary I/O, and XML element tree—are cleanly abstracted and potentially reusable in other scientific or simulation contexts. The repository also includes extensive documentation and tutorials, though the experimental directivity feature is flagged as undocumented.
Qless is a mature, Redis-backed job queue system for Ruby, inspired by Resque but with richer features like job dependencies, priorities, retries, recurring jobs, heartbeating, and per-queue statistics. Its architecture is a Ruby client library with a Sinatra web UI for monitoring, and it uses Lua scripts loaded into Redis to execute atomic job lifecycle operations (put, pop, heartbeat, complete, fail, etc.). This language-agnostic core makes the queue engine reusable from any language that can call Redis EVALSHA. The Ruby gem provides two worker types (Forking and Serial), pluggable job reservers (Ordered, RoundRobin, ShuffledRoundRobin), and a middleware stack for cross-cutting concerns like timeout enforcement, retry logic, exception notifications (Sentry), and memory monitoring. The codebase demonstrates good engineering practices: clear separation of concerns, well-structured middleware pattern, comprehensive test coverage (RSpec with integration and unit tests), and a focus on operational metrics (histograms, fail/retry counts). However, the frontend assets (Bootstrap 2.0.2, outdated jQuery plugins) and some dependencies (Thin, legacy Redis compatibility shims) show technical drift. The project receives active maintenance (recent compatibility updates for Redis 6+ and Valkey 8) but retains some technical debt.