ChromiumHtmlToPdf is a .NET library and CLI tool that converts HTML to PDF (and PNG) using headless Google Chrome or Microsoft Edge via the Chrome DevTools Protocol (CDP). The core library (ChromiumHtmlToPdfLib) provides a managed C# API with synchronous and asynchronous methods for conversion, supporting extensive configuration of page settings, headers/footers, margins, paper size, JavaScript execution, and file caching. The console application (ChromiumHtmlToPdfConsole) wraps this library into a command-line tool with over 50 options, enabling batch conversions, multi-threading, and integration into scripts or CI/CD pipelines. The architecture is a two-project solution: a netstandard2.0/2.1 library and a .NET 8 console app packaged as a dotnet tool. Key entry points include the Converter class (ConvertToPdf/ConvertToImage methods) and the console's Program.cs. External dependencies are limited to a Chromium-based browser (Chrome/Edge) installed on the system, plus NuGet packages for JSON serialization, logging abstractions, and image processing (AngleSharp, Magick.NET). The codebase demonstrates solid engineering with reusable components like a file-backed cache, CDP protocol models, and pluggable loggers, but suffers from minor technical debt such as deprecated BinaryFormatter usage, disabled certificate validation in HTTP helpers, and version drift between projects. No automated tests exist, increasing regression risk for a process-heavy library.
deadlocked is a Linux-only Counter-Strike 2 cheat written in Rust, paired with a web radar stack. The `cheat/` crate (binary `deadlocked`) attaches to the running CS2 process via `process_vm_readv/writev`, resolves game offsets through a combination of pattern scanning (including an AVX2 path), ELF module parsing, and runtime schema walking, then exposes features including aimbot (ray-vs-hitbox intersection), triggerbot, RCS, no-flash, FOV changer, smoke manipulation, grenade alignment/lineups, hitmarkers, and an ESP overlay. The overlay is rendered in a transparent click-through X11 window via winit/glutin/egui_glow, with a separate settings window; mouse output is injected through a fake uinput device. Game state is snapshotted into types defined in the `shared/` crate, sent over TCP (postcard, versioned protocol) to the `server/` relay, and forwarded via WebSocket as JSON to the `radar/` Svelte+Vite frontend that renders live maps, players, entities, and grenade trails. Architecturally this is a four-crate monorepo with clean separation: cheat client, shared protocol crate, relay server, and web frontend. Thread-based component separation (UI message channel, game-manager loop, radar publisher) and a serde/TOML config system with per-weapon overrides show deliberate engineering. The most reusable pieces are the generic process-memory abstraction (`cheat/src/os/process.rs`) and the serialized BVH spatial index (`cheat/src/parser/bvh.rs`); the `shared/` crate is a good example of a versioned client/server/frontend data contract. Weaknesses are domain-inherent: hardcoded offsets and schema class names break with every CS2 update, several values are marked UNKNOWN/todo and are research-grade, and it pulls a dependency from a personal Codeberg repo. It also carries the usual cheat risks (game ToS violation, account bans) and a single-maintainer distribution model that rejects zip downloads and requires git clone.
BetterModel is a server-side Minecraft model rendering engine for Java Edition, distributed as a Bukkit/Paper/Spigot plugin, a Fabric mod, and Maven-published API artifacts. In production it loads Blockbench .bbmodel files at runtime, converts geometry, UVs, and animations into Minecraft item-model JSON and textures, generates or merges resource packs, and streams display-entity packets to clients so animated models can be attached to entities, players, dummies, and mounts. Beyond rendering, it provides public APIs for trackers, hitboxes, nametags, player-skin models, custom armor, event dispatch, scheduling, and third-party integrations with MythicMobs, Citizens, SkinsRestorer, and Nexo. The architecture is a multi-module Gradle build: a platform-independent API module, shared core implementation, Bukkit/Paper/Spigot and Fabric platform bindings, and eight NMS version adapters covering Minecraft 1.21.4 through 26.3. The core data flow is `.bbmodel` JSON -> raw model records -> blueprints -> renderer/rendered bones -> item-display transformations -> packet bundling and resource-pack output. The code is modern, actively maintained, and deliberately designed for high-traffic Paper servers, using Kotlin/Java interop, Adventure, cloud commands, Caffeine, fastutil, JOML, and Paperweight/Fabric Loom tooling. Main strengths are the clean platform abstraction, the public API surface, the packet-bundling and resource-pack generation machinery, and the broad feature set. Main weaknesses are the heavy copy-paste across NMS version modules, a visible lack of automated tests, incomplete Fabric features in places, and heavy reliance on reflection and version-specific internals. Overall this is a solid, professional Minecraft engine implementation with some reusable API-level utilities, but the NMS layer would benefit from generated or shared code to reduce drift risk.
SimScale is a research codebase for data-driven, non-reactive autonomous vehicle simulation and benchmarking, developed by OpenDriveLab. It provides a comprehensive pipeline for training and evaluating end-to-end driving policies on the nuPlan/OpenScene dataset, with support for synthetic data augmentation (SimScale) and multiple agent architectures including Transfuser, DiffusionDrive, and GTRS-Dense. The repository implements a Plan-Do-Measure (PDM) closed-loop scoring framework, metric caching, and a Hydra-based configuration system for flexible experiment management. While primarily a research platform, it includes production-like training scripts, evaluation pipelines, and submission tools for the NAVSIM v2 challenge. The codebase is heavily coupled to the nuPlan ecosystem and requires large-scale data downloads (>1TB), but offers reusable components such as abstract agent interfaces, feature/target builders, and batch IDM policies. It is actively maintained with recent commits and a growing community of extensions.
This repository contains a Linux kernel driver for managing battery health features on Acer laptops via the WMI (Windows Management Interface) interface. The driver enables control of two key battery functions: a health mode that limits charge to 80% to prolong battery lifespan, and a calibration mode that performs a full charge-discharge cycle for accurate capacity reporting. It also provides battery temperature readings. Implemented as a single kernel module (acer-wmi-battery.c), it interacts with the laptop's firmware through WMI methods to query and set battery parameters, exposing these controls via sysfs attributes under /sys/bus/wmi/drivers/acer-wmi-battery/. The driver follows standard Linux kernel module practices, including proper error handling, version-dependent includes for compatibility, and sysfs attribute creation for user-space interaction. It includes reusable WMI helper functions that encapsulate the boilerplate for WMI method calls, buffer handling, and response validation. The project is actively maintained with recent commits, supports multiple Acer laptop models as documented in MODELS.md, and is licensed under GPL-2.0.
This repository implements 'Kara', a KDE Plasma 6 applet that functions as a desktop/workspace pager. It allows users to switch between virtual desktops or activities via a configurable widget that can display pills, text labels, or icons. The applet supports multiple highlight styles (line, square, full, full with line), scrolling and click interactions, and custom labeling with templates. The architecture consists of a C++ plugin providing the PagerModel and WindowModel (using KWin and TaskManager APIs) and QML files defining the user interface, representation components, and highlight overlays. The project is actively developed with 37 open issues and 327 stars, and is built for modern KDE Frameworks 6 and Qt6.
AveYo/Gaming is a collection of Windows batch/PowerShell scripts, game configurations, and embedded C# libraries focused on optimizing Counter-Strike 2, Dota 2, and Steam for performance, stability, and quality-of-life. It provides a sophisticated CS2 launcher that dynamically switches desktop resolution to match game resolution to fix alt-tab and input lag issues, a crash dump reader (DmpChk) using the Windows debug engine, a GPU shader cache cleaner, a Steam launcher in 'Small Mode' to reduce resource usage, and a suite of CS2 performance benchmarking tools using in-game console automation and CSV output analysis. The repository also includes extensive game config files (autoexec.cfg for CS2 and Dota2) with performance tweaks, and scripts for offline play via a Steam emulator (SEMU). While tightly coupled to specific game paths and Windows APIs, several components are well-crafted and self-contained, particularly the custom C# SetRes display resolution library and the VDF file parsing routines.
OrbbecSDK is a cross-platform C/C++ software development kit for Orbbec 3D cameras, supporting depth, color, infrared, and IMU sensors. It provides both a high-level Pipeline API for easy stream management and a low-level Device/Sensor API for fine-grained control. The architecture is library-based with a C API (ObSensor.h) and a C++ wrapper (ObSensor.hpp), following a consistent pattern of context creation, device enumeration, stream configuration, frame acquisition, and post-processing via composable filters. Key entry points include Context (device discovery), Pipeline (streaming), Device (property control), and Filter (alignment, point cloud generation, noise removal, etc.). Data flows involve configuring stream profiles, starting the pipeline, receiving frames (depth, color, IR, IMU), applying filters (e.g., depth-to-color alignment, HDR merge, spatial/temporal filtering), and optionally recording or replaying streams. External dependencies include OpenCV for example visualizations, cJSON for multi-device synchronization configuration, and platform-specific USB drivers. The SDK is used in robotics, AR/VR, industrial inspection, and 3D scanning applications.
This repository is an educational resource focused on teaching the Gang of Four (GoF) design patterns through comprehensive explanations, code examples, and diagrams. It covers creational, structural, and behavioral patterns, with each pattern accompanied by detailed markdown documentation, visual diagrams, and runnable code samples in both Java and Kotlin. The project structure organizes content by pattern type, making it easy to locate and study specific patterns. The code examples demonstrate practical implementations of each pattern in context-specific scenarios, such as a banking system for the Command pattern, a notification system for the Decorator pattern, and a file system for the Composite pattern. While the build configuration defaults to running a Singleton demo, each pattern includes independent main functions or demo classes that can be executed separately. The repository also features automated workflows for building and deploying the documentation via GitHub Pages. Despite some maintenance challenges like duplicate documentation files (marked for removal in a future version) and the coexistence of Java and Kotlin examples, the project shows active maintenance through contribution guidelines, regular updates, and a clear migration path toward consolidating documentation. The examples are well-crafted, self-contained, and illustrate core object-oriented design principles effectively, making them valuable for both learning and reference purposes.
agentsre is a Python library that applies Site Reliability Engineering (SRE) practices to AI agent systems. It provides reliability instrumentation for production agents: semantic validation of agent outputs, SLI metrics collection, circuit breaking, escalation baseline detection, cost tracking, and structured audit logging. The codebase is organized as a package with a core reliability module (aos_reliability.py), an orchestration subpackage for control-plane SLIs, a validation layer for agent decisions, and a cost optimizer for LLM spend. It also includes a fintech orchestration demo and documentation for running agents in payment systems. Architecturally, it is a library rather than a service: consumers import the Python API and embed checks into their agent loop. The primary data flow is agent action -> semantic validation -> reliability/risk checks -> orchestration SLI recording -> audit log. The system tracks metrics like escalation rates and decision quality, and can block or allow requests via a circuit-breaker style interface. External dependencies are minimal, with optional cost-optimizer imports guarded by try/except. Maintenance is active, with CI workflows, tests, and a changelog. The code is well-documented and the modules are mostly self-contained, making several components extractable for reuse in other agent platforms.
This repository is the official Chinese addons collection for the Fcitx5 input method framework. It provides Pinyin (including Shuangpin) and Table-based input methods (Wubi, Cangjie, Erbi, etc.), along with supplementary modules for cloud pinyin, simplified/traditional Chinese conversion (via OpenCC), fullwidth/halfwidth toggling, punctuation mapping, pinyin lookup, and stroke filtering. The architecture follows a modular plugin system: each input method and module is a separate Fcitx5 addon that registers via factory macros and is loaded dynamically at runtime. The codebase also includes Qt5-based GUI tools for managing pinyin dictionaries and custom phrases. Data flows involve loading binary dictionaries (libime format), stroke tables, symbol maps, and user learning files (user.dict, user.history), plus optional HTTP requests for cloud pinyin. External dependencies include fcitx5 core, libime, libcurl, nlohmann_json, OpenCC (optional), Lua (optional), and Qt5 (for GUI). The project is actively maintained with a large set of well-structured C++ source files and comprehensive i18n support.
This repository implements the Node.js GitHub organization's automation bot. It is a small Express webhook receiver that accepts GitHub deliveries at /hooks/github and Jenkins CI callbacks at /:repo/jenkins/:event, validates the incoming HMAC signatures, and dispatches events through an asynchronous event bus to per-script handlers. The included scripts handle pull-request events by pinging code owners, updating CI commit statuses, posting comments about build failures, and relaying Jenkins outcomes to GitHub Actions via repository dispatch. There is no persistent database; all state lives in GitHub and Jenkins, making the bot effectively a stateless event-driven automator.
This repository implements a Cobalt Strike Beacon Object File (BOF) that loads .NET assemblies directly into memory while employing hardware breakpoint-based techniques to bypass AMSI and ETW monitoring without patching memory. The core functionality resides in the C source file which handles .NET runtime initialization, assembly loading, and the innovative hardware breakpoint mechanism for security bypass. The project includes an Aggressor script for integration with Cobalt Strike's command framework. The code demonstrates advanced Windows API manipulation, COM interop for .NET hosting, and stealth techniques that avoid traditional memory patching detectable by EDR solutions.
The Doomsday Engine is a modular game engine and source port for classic FPS games (Doom, Heretic, Hexen, Doom64) with client-server architecture. It provides enhanced rendering (OpenGL), audio systems, GUI frameworks, networking, and scripting capabilities. The engine supports extensibility via plugins and includes tools like Amethyst for documentation processing. The codebase shows strong separation of concerns with distinct libraries for core functionality, game logic, rendering, and UI. While actively maintained, it exhibits technical drift due to platform-specific conditionals, legacy code sections, and complex dependency management.
ScenarioNet is a data-centric toolkit for managing and converting autonomous driving datasets into a unified scenario format. It provides converters for Waymo, nuScenes, nuPlan, Argoverse 2, VoD, and procedural generation (PG) datasets, transforming raw data into a common ScenarioDescription structure compatible with the MetaDrive simulator. The repository includes dataset management operations (merge, split, filter, copy), verification tools (existence and simulation checks), and utilities for handling scenario metadata. While it contains training and evaluation scripts for machine learning models, its primary focus is on data preparation and scenario engineering for autonomous driving research. The data lineage involves ingesting raw datasets via dataset-specific toolkits, extracting scenario elements (object tracks, map features, traffic signals, timestamps), and serializing them into pickle-based dataset structures with mapping and summary files. These outputs enable downstream tasks such as multi-dataset aggregation, scenario filtering for ML training, simulation-based validation, and dataset splitting. The toolkit addresses research questions around dataset scalability, scenario diversity, and reproducible evaluation of autonomous driving systems by providing a standardized interface across heterogeneous data sources. Key reusable components include the modular converter utility for multiprocessing data transformation, generic dataset operations (merge/split/copy) that operate on the standardized scenario format, and a verification framework with parallel processing and error reporting. These components demonstrate solid data engineering practices but are tempered by dependency management issues (commented-out packages requiring manual installation), hardcoded paths in training scripts, and reliance on external SDKs that may introduce version drift.
ttab is a single-file Bash CLI that programmatically opens new terminal tabs and windows on macOS (Terminal.app and iTerm2) and Linux (gnome-terminal). It supports running startup commands in the new tab, setting working directory, title, and profile, creating iTerm2 horizontal/vertical splits (-v/-h), creating tabs without stealing focus (-g/-G), delaying command submission (-l), and clearing the screen (-q). The entire application is bin/ttab: a ~700-line Bash script with zero runtime dependencies that parses options via getopts, detects the calling terminal through TERM_PROGRAM / GNOME_TERMINAL_SCREEN or an explicit -a flag, synthesizes backend-specific automation (AppleScript for Terminal.app and iTerm2, with distinct v2/v3 syntax paths, and a CLI argument string for gnome-terminal), and executes it via 'exec osascript' on macOS or eval on Linux. It embeds its full Markdown man page as a here-doc extracted by sed, so --help, --man, and --man-source all work from the single distributed file.
This repository is the official documentation site for the LinuxBoot project, built with mdBook and deployed to GitHub Pages. It provides comprehensive guides, case studies, tool documentation, and historical background for replacing proprietary firmware with Linux-based boot firmware. The site supports internationalization (i18n) for Traditional Chinese and uses custom theme components for language switching. The CI pipeline includes linting for markdown and prose quality, and automated deployments. The repo is not an application or data pipeline but a static documentation site. Its reusability lies in the well-structured mdBook setup, the multilingual translation pipeline (i18n.sh), and the custom UI components (language-picker.js). These can be extracted and reused in other documentation projects. However, some technical content (kernel configs, tool versions) is dated, and the i18n translation has many fuzzy entries requiring review. Architecture: mdBook static site generator with mermaid diagrams, link checking, i18n via gettext, and GitHub Actions for CI/CD. No runtime services or APIs exist.
Parsons is a Python library providing a unified interface to dozens of third-party services commonly used in progressive political campaigns and advocacy organizations. It acts as an ETL/integration toolkit, with a core `Table` abstraction (backed by petl) that normalizes data from APIs, databases, and file formats. The library includes connectors for voter file platforms (NGP VAN, PDI, TargetSmart, Catalist), fundraising (ActBlue, Donorbox, Braintree), communication (Twilio, Slack, Gmail), event management (MobilizeAmerica, ActionNetwork), and cloud storage (S3, GCS, Azure). It also provides database connectors (Postgres, Redshift, BigQuery, MySQL, SQLite) and utilities for dbt integration, credential management, and file handling. The architecture is a monolith of loosely coupled connector modules, each following a consistent pattern of credential resolution via environment variables and returning `Table` objects. The codebase is well-tested with unit tests (mocked) and some integration tests, but many connectors rely on external APIs that may drift. The library is actively maintained by The Movement Cooperative, with recent commits and CI/CD pipelines.
PyMFEM is a Python binding layer for MFEM, the LLNL finite element method library. In practice it lets users define and solve PDE problems (Poisson, elasticity, Maxwell, DG, DPG, Navier-Stokes, topology optimization, etc.) from Python by wrapping the C++ MFEM library through SWIG. The package exposes serial (`mfem.ser`) and MPI-parallel (`mfem.par`) modules, supports Python-defined coefficients and operators via SWIG directors, includes Numba JIT acceleration for coefficient callbacks, and integrates with mpi4py, hypre, libCEED, GSLIB, GLVis, and VisIt. It is a numerical library rather than a service or data pipeline; it has no API endpoints, but it ships dozens of executable examples that serve as reproducible solver templates and also contains issue-specific regression fixtures for mesh/visualization bugs.
This is a collection of 12 lessons on effective AI-assisted software development, derived from real-world experience with tools like Cursor, Windsurf, Cline, and Claude. It is not a software application or data research project—it is pure documentation. The lessons cover project structure, planning, problem decomposition, test writing, commit discipline, and prompt engineering. The content is clear, concise, and immediately applicable. No code or data pipelines are present; the value lies in the reusable practices and mental models it teaches.