This repository provides an ESPHome external component and a Home Assistant custom component for controlling Mitsubishi heat pumps via the CN105 serial interface. The core component implements a full climate controller with dual setpoint support, multiple operating modes (heat, cool, heat_cool, dry, fan_only), fan speeds, swing modes, remote temperature integration, and a wide array of sensors (compressor frequency, power, kWh, outside temperature, error codes, etc.). It communicates with the heat pump over UART at 2400 baud using a reverse-engineered protocol with checksum validation and cyclic request scheduling. The Home Assistant proxy component dynamically adjusts the UI to show single or dual setpoint sliders based on the active mode, fixes Auto mode behavior, and supports advanced features like coordinator single-target mode for multi-zone systems. The codebase is well-structured with standalone reusable modules for frame parsing, protocol encoding/decoding, request scheduling, and temperature conversion, supported by a comprehensive unit test suite and CI pipeline. The repository includes example configurations for various microcontrollers (ESP32, Xiao, M5Stack) and deployment scenarios, making it a mature and practical solution for integrating Mitsubishi heat pumps into smart home systems.
Sylve is an open-source FreeBSD infrastructure management platform written in Go. It provides a unified control plane for managing bhyve virtual machines, FreeBSD jails, ZFS storage, and networking (including VLANs, switches, DHCP, PF firewall, WireGuard, and mDNS). The system supports high-availability clustering via Hashicorp Raft consensus, with built-in backup/replication (Zelta) and live migration of workloads. It exposes a REST API (Gin), a CLI/REPL (Bubbletea TUI), and a SvelteKit web frontend. The architecture is modular with interface-based services, middleware for auth and request limiting, and a typed console protocol over Unix sockets. The codebase is heavily tested with unit, integration, and real-ZFS tests, and is licensed under BSD-2-Clause with sponsorship from the FreeBSD Foundation.
nnsight is a Python library for interpreting and intervening in neural network models during execution. It provides a tracing API that allows users to access and modify internal activations, compute gradients, and perform interventions like activation patching and steering. The system uses a deferred execution model with thread-based synchronization to run user intervention code alongside model forward passes. Key features include support for Hugging Face models, vLLM integration for high-performance inference, remote execution via NDIF infrastructure, and persistent model editing. The architecture centers around Envoy wrappers for modules, a tracer/interleaver system for coordinating execution, and a batching mechanism for efficient multi-input processing.
DreamDojo is an application repository for training and deploying world foundation models, particularly focused on robotics applications. The system provides end-to-end capabilities for training Cosmos Predict2 models, generating text/video-to-video outputs, action-conditioned video generation for robot control, and model distillation for efficient inference. It features a modular architecture with Hydra-based configuration, distributed training support (FSDP, tensor parallelism, context parallelism), and interactive Gradio demonstrations. The codebase includes sophisticated safety filtering mechanisms and is designed for deployment via Docker containers.
This is a monorepo for General Translation (GT), a comprehensive internationalization (i18n) and localization (l10n) platform. It provides runtime libraries for React, Next.js, Vue, React Native, Node.js, and Python frameworks, enabling developers to translate entire React components—not just strings—using a simple `<T>` wrapper. The platform includes a CLI for extracting translatable strings from source code, uploading them to a translation service, and downloading completed translations. A Babel/SWC compiler injects translation hashes at build time, and a Sanity CMS plugin manages document-level translations. The architecture is a multi-package monorepo with shared core types, a compiler pipeline, framework-specific adapters, and a cloud API client. The codebase demonstrates high craftsmanship with clean abstractions like condition stores, singleton caches, batch processing utilities, and a step-based workflow pattern. It is actively maintained with extensive test coverage and modern tooling (pnpm, Turborepo, TypeScript, Vitest).
CamillaDSP is a real-time audio stream processing engine written in Rust. It captures audio from a configurable backend (ALSA, PulseAudio, PipeWire, CoreAudio, WASAPI, ASIO, or file), processes it through a user-defined pipeline of filters, mixers, compressors, and other DSP components, and outputs it to a playback device. The pipeline is defined via YAML configuration, supporting biquad filters, FIR convolution (with hand-optimized NEON and AVX+FMA SIMD kernels), loudness, limiting, noise gates, and dithering. A websocket-based control interface allows runtime adjustments of volume, mute, faders, and config reloads. The architecture is modular with separate threads for capture, processing, and playback, using a PI rate controller for buffer level regulation. Benchmarks demonstrate attention to performance. While primarily an application, the DSP filter implementations and utility components (ring buffer, conversion routines, rate controller) are reusable building blocks for audio software.
This is a Go-based video parsing tool that removes watermarks from videos across 20+ Chinese social media platforms (Douyin, Kuaishou, Bilibili, Weibo, etc.). It provides three interfaces: a CLI tool (using Cobra subcommands `serve`, `parse`, `id`, `version`), an HTTP API (Gin-based with v1 RESTful endpoints and legacy backward-compatible routes), and a reusable Go library. The architecture is a monolith with a clean separation: `parser/` package contains platform-specific parsers implementing strategy pattern interfaces, `cmd/` package handles CLI and HTTP server logic with a middleware stack (recovery, CORS, rate limiting, basic auth, logging), and `utils/` provides URL extraction. The system is stateless, uses no database, and relies on HTTP scraping and API calls to extract video metadata. Notable engineering craftsmanship includes a custom anti-crawling a_bogus signature generation for Douyin's native detail API (SM3 hash, RC4 encryption), a concurrent-safe proxy injection via atomic.Value, and a well-tested middleware stack with IP-based rate limiting using sync.Map and periodic cleanup. The codebase has comprehensive unit and integration tests, CI/CD pipelines, and Docker support.
This is a software library for parsing and processing IFC (Industry Foundation Classes) BIM files, primarily designed for web environments. It consists of a C++ core that reads IFC STEP files, resolves geometry (including extrusions, sweeps, Boolean CSG operations, and advanced curves like B-splines and clothoids), and generates triangulated meshes. The C++ code is compiled to WebAssembly via Emscripten, and a TypeScript API (IfcAPI) exposes all functionality to JavaScript applications in both browser and Node.js. The library supports multiple IFC schema versions (IFC2X3, IFC4, IFC4X3) and includes a schema generator that produces C++ and TypeScript type definitions from EXPRESS schema files. The architecture is a classic native-to-web bridge: the C++ library handles all heavy geometry and parsing, while the TypeScript layer provides a clean interface for loading models, streaming meshes, reading/writing properties, and creating new geometry. Key entry points include the IfcAPI class (open/close models, load geometry, save models), the C++ IfcGeometryProcessor and IfcGeometryLoader for mesh generation, and the IfcLoader for token-based IFC parsing. External dependencies include GLM (math), spdlog (logging), mapbox/earcut (triangulation), and CDT (constrained Delaunay triangulation). A comprehensive test suite using real IFC files and regression hash checks ensures geometry stability across versions. The library is production-ready but shows some technical drift: pinned dependency commits, large monolithic source files, and generated schema headers that must be manually regenerated. It remains actively maintained with CI/CD pipelines, issue triage, and regular releases (v0.0.78).
FreeOrion is a turn-based space empire building game (4X: eXplore, eXpand, eXploit, eXterminate) inspired by the Master of Orion series. The architecture follows a client-server model where the server manages game state and rules, while clients (human or AI) interact via GUI or scripting. Game content is defined via FreeOrion Content Scripts (FOCS), Python-like scripts parsed by a C++ engine using Boost.Spirit. The human client uses the GiGi (GG) library for OpenGL-based rendering and UI. Key systems include empire management (resources, production, research), ship design and combat, planet colonization, diplomacy, and AI-driven opponents. The project supports modding through FOCS and has active cross-platform development with CI workflows for Linux, macOS, and Windows.
This repository is a complete ROS2 software development kit for the Unitree Go2 quadruped robot. It provides a high-level SDK (go2_robot_sdk) with clean architecture (domain, application, infrastructure, presentation) that enables connection to the robot via WebRTC (Wi-Fi) or CycloneDDS (Ethernet), reception and decoding of real-time data (LiDAR, IMU, joint states, camera, odometry), and control commands (movement, stance, joystick). It includes multiple ROS2 packages: go2_interfaces (25+ custom message types), lidar_processor (Python and C++ nodes for LiDAR point cloud decoding and aggregation), speech_processor (ElevenLabs TTS with caching and robot playback), coco_detector (object detection using PyTorch FasterRCNN), and launch files for SLAM (slam_toolbox) and autonomous navigation (Nav2). The repository also contains URDF models, calibration files, RViz configurations, Docker support, and multi-robot namespace remapping. While primarily an application for controlling and monitoring the Go2 robot, it includes data-processing components (LiDAR decoding, IMU filtering, object detection) that give it a hybrid data-research character. The codebase demonstrates professional ROS2 development practices with modular design, abstract interfaces, and multiple language implementations.
DexKit is a high-performance C++ library for runtime parsing and querying of Android DEX bytecode, primarily used by Xposed module developers to locate obfuscated classes, methods, and fields. It provides a rich DSL in Kotlin/Java for constructing structural queries based on annotations, opcodes, string usage, field/method references, and more. The core engine parses DEX files from APK archives, builds in-memory indexes, and uses algorithms like Aho-Corasick for substring matching and the Hungarian algorithm for unordered set matching. Communication between the native C++ layer and JVM is handled via FlatBuffers serialization. The library also includes an optional caching layer (`DexKitCacheBridge`) for persisting query results across app restarts. It is distributed as an Android AAR via Maven Central and includes a demo app and unit tests.
This repository provides a set of custom nodes for ComfyUI that enable 'broadcast' or 'virtual link' functionality. Instead of manually connecting every node input, users can connect data to an 'Anything Everywhere' node, which then automatically routes that data to any unconnected input of the same type across the workflow. This dramatically reduces visual clutter and simplifies complex workflows. The system supports advanced filtering via regex, group/color restrictions, priority resolution, and subgraph compatibility. It also includes a 'Combo Clone' node for broadcasting dropdown values and a 'Seed Everywhere' node for seed synchronization. The architecture is split between Python backend node definitions (in `use_everywhere.py`) and a rich JavaScript frontend that handles graph analysis, virtual link rendering, and user interface. The core logic resides in the JS modules: `use_everywhere_graph_analysis.js` analyzes the graph to determine which inputs can be connected, `use_everywhere_classes.js` models the broadcast links, and `use_everywhere_ui.js` renders the virtual connections with animations and highlights. The system integrates deeply with ComfyUI's graph lifecycle, intercepting prompt submission to temporarily convert virtual links into real links for execution. Key entry points include the Python node classes (`AnythingEverywhere`, `ComboClone`, etc.) and the JavaScript extension registration in `use_everywhere.js`. The primary data flow is: user connects data to a UE node → graph analysis identifies matching unconnected inputs → virtual links are stored in graph metadata → on prompt, virtual links are materialized as real links → after execution, links are removed. External dependencies are minimal: it relies on ComfyUI's frontend package and standard web APIs.
Tutel is a high-performance library for Mixture-of-Experts (MoE) in PyTorch, focused on both training and inference of large-scale sparsely-gated models. The codebase is organized into distinct layers: the core `MOELayer` configuration (gating, experts, dispatch), custom NCCL-based distributed communication primitives (`net.py`), JIT-compiled CUDA/ROCm kernels for routing and sparse operations, and utility modules for checkpoint resharding across different distributed topologies. Heavily exploited features include low-precision quantized inference (FP4, FP8, block quantization), fused Expert comunication via all-to-all collectives, and a experimental auto-paritioning solver for adaptive parallelism. The repository is dominated by software engineering artifacts (Python library design, C++/CUDA/ROCm extensions and binaries, structured examples) rather than research notebooks or analytic pipeline, but its origins include published papers (MLSys 2023) and active development for contemporary models such as DeepSeek, Qwen3, and Kimi.
zpp_bits is a modern C++20 header-only binary serialization library that provides high-performance, zero-overhead serialization and deserialization of C++ objects. It supports multiple wire formats including a custom compact binary format and an optional protobuf-compatible protocol (zpp::bits::pb) for cross-language interoperability. The library also includes a built-in RPC framework (zpp::bits::rpc) that can generate client/server stubs from function bindings, and compile-time utilities for hashing (SHA-1, SHA-256) and byte manipulation. The architecture is template-heavy, leveraging C++20 concepts, constexpr evaluation, and structured bindings to automatically serialize aggregates without explicit reflection. Error handling is based on std::errc with optional coroutine support via zpp_throwing. The library is self-contained in a single header file (zpp_bits.h) with no external dependencies beyond the C++ standard library, making it easy to integrate into any C++20 project. It is extensively tested with a vendored copy of Google Test and includes CI pipelines for multiple compilers and C++ standards (C++20 through C++26).
Rattles is a minimal, dependency-free Rust library for terminal spinners and throbbers. It provides a collection of preset animations (arrows, ASCII, braille, emoji) and a flexible API for driving them via time, ticks, or frame index. The library supports both std (with a global clock via `Instant`) and no_std environments, and includes a `rattle!` macro for defining custom spinners. The architecture uses const generics for direction control (forward/reverse) and compile-time keyframe storage, enabling zero-cost abstractions. It is designed for integration with TUI frameworks like Ratatui, demonstrated by the example. The codebase is well-structured, with clean separation of concerns: `rattler` (time-based), `ticked_rattler` (stateful tick-based), and presets modules. The library has no external dependencies (except dev-dependencies for examples), and the macros generate efficient, compile-time validated spinners.
This is a Nuxt module for device detection that provides a reactive `$device` object and `useDevice()` composable. It determines device type (mobile, tablet, desktop), operating system (iOS, Android, Windows, macOS, Linux), browser (Chrome, Firefox, Edge, Safari, Samsung), and crawler status by parsing the User-Agent header and/or CDN-provided headers (Amazon CloudFront, Cloudflare). The core detection logic is encapsulated in `src/runtime/generateFlags.ts`, which is a standalone, well-tested function. The module is built for Nuxt 3+ (ESM-only) and uses `crawler-user-agents` for crawler detection with a build-time generated regex for performance. The codebase is small, focused, and demonstrates good engineering practices with clean separation of concerns, comprehensive tests, and proper use of Nuxt module APIs.
This is the NVIDIA RAPIDS Accelerator for Apache Spark (formerly cudf-spark), a high-performance Spark SQL plugin that replaces CPU-based Spark physical operators with GPU-accelerated equivalents using the cuDF library. The codebase provides a comprehensive shim layer supporting over 20 distinct Spark versions (3.3.x through 5.0.x) including Databricks runtimes, along with deep integrations for Delta Lake (2.x–4.x) and Apache Iceberg (1.6–1.11). It implements GPU versions of nearly every Spark SQL execution node: scans, joins, aggregates, windows, shuffles, file format readers/writers for Parquet, ORC, CSV, JSON, Avro, and Hive. The architecture relies on a sophisticated multi-version shim pattern, service-loading providers, and extensive use of Spark internal APIs to intercept and redirect execution to GPU columnar operations. The repository also includes a UDF compilation framework that converts Scala UDFs to GPU expressions, and a set of performance profiling and metrics tools. Despite its massive scope and high shim count, the codebase is well-structured with clear separation of concerns, comprehensive testing, and active release cadence. It is primarily an application (Spark plugin) with some auxiliary tooling for data generation and testing, but no data research elements.
Laravel Authentication Log is a Composer package/library for Laravel applications that records authentication events (login, failed login, logout, and other-device logout) for any Eloquent model using the supplied AuthenticationLoggable trait. Its core is an event-listener architecture driven by Laravel's auth events, writing rows to a polymorphic authentication_log table with IP address, user agent, device fingerprint, location, timestamps, and flags for trust and suspicious activity. The package also adds session restoration prevention (so page refreshes and remember-me restorations update last_activity_at instead of creating duplicate rows), device trust management, statistics, query scopes, notification rate limiting, webhooks, and artisan commands for purging and exporting logs.
The OpenCog AtomSpace is a hypergraph-based knowledge representation system serving as the core component for Artificial General Intelligence (AGI) research. It provides an in-memory database for storing immutable, uniquely-typed atoms (nodes and links) with mutable key-value stores attached for dynamic data. The system supports executable graphs through the Atomese language, features a sophisticated pattern matching and query engine, includes type inheritance and intersection capabilities, and offers multi-language bindings (Scheme, Python). Architecture-wise, it follows a modular design with clear separation between atom management, value systems, execution frameworks, and query processing. The codebase demonstrates strong engineering practices with factory patterns, handle-based memory management, and thread-safe frame stacks for evaluation contexts.
onnx2tf is a production-ready ONNX to TensorFlow/TFLite conversion framework that employs a sophisticated pass-based optimization pipeline. The system converts ONNX models through preprocessing, lowering to an intermediate representation (ModelIR), applying 50+ optimization passes (layout transformation, operator fusion, quantization), and exporting to target formats including TFLite, SavedModel, PyTorch nn.Module, and TorchScript. Its architecture features clean separation between operator implementations, IR transformation passes, and backend-specific exporters, with the flatbuffer_direct backend providing 100x+ faster conversion by bypassing TensorFlow graph construction. The framework includes comprehensive accuracy validation tools, dynamic shape handling, and model surgery capabilities for intermediate layer extraction.