This repository is a Laravel package that extends the framework's localization capabilities to include country-specific formatting. It provides a middleware that automatically detects the user's preferred language and country from browser headers or user profile, sets session variables, and offers a facade with methods to retrieve localized date formats, currency symbols, country names, and emoji flags. It also includes a language switcher controller and listens to login events to persist user preferences. The architecture follows Laravel's service provider pattern, with a main LangCountry class that reads data from bundled JSON files for each supported locale. The package integrates with Carbon for date formatting and provides Carbon macros for convenient use. The codebase is well-tested with 100% coverage, typed, and follows PSR-12 coding standards. The most reusable component is the PreferredLanguage service, which encapsulates the logic of parsing the Accept-Language header and matching against allowed locales with quality weighting and fallback. This could be extracted into a standalone library for browser language detection in any PHP project.
Rubicon-ObjC is a bridge library enabling Python to interact with Objective-C runtime and frameworks. It allows instantiation and invocation of Objective-C objects from Python, subclassing Objective-C classes in Python, and automatic conversion between Python and Objective-C data types. The library is part of the BeeWare suite for cross-platform Python GUI development, targeting iOS/macOS platforms. Architecture centers around modular submodules: api (high-level decorators and wrappers), runtime (low-level Objective-C interactions), types (data conversion), collections (Foundation collection wrappers), and eventloop (asyncio integration). Key features include bidirectional type conversion, decorator-based exposure of Python to Objective-C, block handling, and memory management automation. The library is used in production iOS apps (e.g., Travel Tips) and serves as a dependency for other BeeWare projects like Toga.
LiveSplit One is a cross-platform speedrun timer application, the successor to the classic LiveSplit timer. It runs as a Progressive Web App and as a Tauri desktop application, targeting Windows, Linux, and macOS. The core timing logic is compiled to WebAssembly via the 'livesplit-core' Rust library, while the UI is built with React 19, TypeScript, and Vite. The application provides a rich set of features for speedrunners: highly customizable split timers, real-time comparisons, layout editor with drag-and-drop, integrated leaderboards from Speedrun.com, global hotkeys (desktop only), always-on-top mode, WebSocket server for remote control, and support for multiple timekeeping methods (real time vs game time). Data persistence is handled via IndexedDB in the browser and the filesystem in Tauri. The codebase is well-structured with a clear separation between core logic (WASM), UI components, and platform-specific code, though some central components like 'LiveSplit.tsx' are large and could benefit from further decomposition.
Custom Pod Autoscaler is a Kubernetes operator that provides custom autoscaling functionality. It runs as a pod in a Kubernetes cluster, periodically gathering metrics (via custom scripts or Kubernetes metrics server), evaluating those metrics to determine desired replica count, and scaling target resources accordingly. The application features a REST API for manual interaction, supports hooks for custom logic at various points in the process, and is designed to work with any language or framework through shell commands or HTTP requests. The architecture follows clean separation of concerns with distinct packages for configuration loading, execution abstraction, metric gathering, evaluation, and scaling logic.
This repository provides a Claude Code Skill for reducing AIGC detection rates in Chinese academic writing. The Skill is available in two versions: a compact SKILL.md (~414 lines) for efficient daily use and a full SKILL_full.md (~554 lines) with detailed examples for maximum effectiveness. It does not contain executable code but offers a comprehensive set of rewriting rules based on 16 identified AI writing patterns across content, language, and style layers. The core methodology involves pattern recognition, constrained rewriting (7 hard constraints), a 4-step SOP (risk scanning → rewriting → rhythm check → noise preservation), and a 6-dimension quality scoring system. The Skill transforms input text by breaking AI predictability while preserving academic meaning and injecting human-like variability through techniques like theoretical repositioning, asymmetric restructuring, and judicious noise retention.
This repository is a comprehensive personal R&D platform implementing a polyglot microservices architecture. It hosts a personal website/web application (React/Vite), multiple API servers in different languages (Rust/Axum, Go/Gin/gRPC, Python/FastAPI, Node.js/Express), mobile applications (iOS/Android/React Native), and desktop applications (Qt). The platform includes extensive data processing infrastructure (Kafka, Pulsar, NATS, Spark, Flink), machine learning capabilities (model training/serving/fine-tuning), monitoring and observability tools, and infrastructure as code (Terraform/OpenTofu, Kubernetes). Services communicate via messaging systems and APIs, with a clear separation of concerns and standardized patterns for configuration, health checks, logging, and error handling across language implementations.
libplctag.NET is a .NET library providing two NuGet packages for industrial PLC communication via EtherNet/IP and Modbus TCP. The primary package (libplctag) offers a high-level, asynchronous, strongly-typed API built on top of the native libplctag C library, handling resource cleanup, exceptions, and event-driven operations. The second package (libplctag.NativeImport) exposes a low-level P/Invoke wrapper that manages platform-specific native binary loading and provides raw tag access. The architecture is a classic wrapper layer: the high-level Tag class encapsulates native handle lifecycle, attribute string generation, synchronous and async operations (using TaskCompletionSource with concurrent stacks to handle native callbacks), and exposes typed data accessors. The library targets a wide range of .NET frameworks (netcoreapp3.0 through net8.0, plus .NET Framework 4.7+), reflecting its industrial compatibility requirements. Some parts of the codebase (the generic Tag<M,T> and associated PlcMappers) are marked obsolete due to a planned API redesign (referenced as issue #406), indicating ongoing evolution.
This repository provides a Python library for parsing human-readable time expressions into seconds. The core functionality is implemented in the `timeparse` function, which accepts strings in various formats (e.g., '32m', '2h32m', '1w3d2h32m', '4:13:02', '2 days, 4:13:02') and returns the equivalent duration in seconds as an integer or float. The library handles optional signs, fractional values, and ambiguous colon-separated values via a granularity parameter. It has no external dependencies and is designed for simplicity and reliability. The library is structured as a single module with a clear public interface. The implementation uses a series of regular expressions to match different time formats and converts the matched components to seconds using predefined multipliers. The code is well-tested with a comprehensive test suite that covers the various input formats and edge cases. Despite its simplicity, the library demonstrates careful attention to detail in handling the complexities of time expression parsing, such as supporting both written and abbreviated units, handling spaces and commas as separators, and providing control over the interpretation of colon-separated values.
Methanol is an extensible HTTP client library built on Java's java.net.http package. It provides core HTTP functionality enhanced with features like automatic decompression (gzip, deflate, Brotli), pluggable body adapters for JSON/XML/Protobuf, HTTP caching with multiple backends (memory, disk, Redis), request/response interceptors, retry mechanisms, progress tracking, and Kotlin DSL support. The library follows a modular architecture with separate modules for core functionality, format adapters, extensions, and testing. Key entry points include Methanol.Builder for client creation, MutableRequest for request building, and BodyAdapter for encoding/decoding. Data flows involve request interception, body encoding, HTTP exchange via java.net.http, response interception, body decoding, and optional caching/progress tracking. External dependencies vary by module: core requires only JDK 11+, while adapters depend on libraries like Jackson/Gson/Moshi, extensions on Redis Lettuce or native Brotli, and testing on JUnit5/MockWebServer.
ember-cli-materialize is an Ember.js addon that provides Materialize CSS components as Ember components. It allows developers to use Materialize UI elements (buttons, cards, modals, forms, etc.) in Ember applications by wrapping them in Ember-friendly components. The addon imports Materialize CSS and fonts, provides a comprehensive set of UI components, and handles the integration between Ember's runloop and Materialize's JavaScript plugins. It follows Ember CLI addon conventions with components, templates, styles, initializers, and services organized in standard directories.
Alchemist is a Flutter package designed to simplify and enhance golden testing in Flutter applications. It addresses the common challenge of platform-specific text rendering inconsistencies by providing two types of golden tests: platform tests that render text normally for local development and visual verification, and CI tests that replace text with colored blocks to ensure consistent results across different operating systems and CI environments. The package features a sophisticated configuration system using Dart zones that allows hierarchical configuration management, enabling developers to set global defaults while overriding specific settings for individual tests or test groups. It provides a clean API for defining test scenarios, organizing them in groups, and automatically handling the complexities of widget pumping, image capture, and comparison with configurable tolerance for minor rendering differences. Technical highlights include a custom painting context that replaces text with colored rectangles for CI consistency, a flexible grid layout system for organizing multiple test scenarios, and robust resource management that ensures proper cleanup after each test. The package maintains 100% test coverage and demonstrates strong engineering practices through its use of immutable data structures, proper resource management, and clear separation of concerns.
Bot Studio is a Next.js-based web application designed for testing and managing OpenAI models through an interactive chat interface. The application allows users to configure API credentials, manage files for fine-tuning, create and monitor fine-tuning jobs, list and delete custom models, and interact with multiple chat windows to test model responses with configurable parameters. The architecture follows a modular approach with React contexts for global state (OpenAI configuration), Zustand stores for domain-specific state (chats, files, fine-tunes, models), and React Query for data fetching and synchronization with the OpenAI API. The user interface is built using Tailwind CSS and Headless UI, with a collection of custom, reusable components for forms, buttons, modals, and toast notifications. Key features include streaming responses from the OpenAI API via a custom hook, file upload/download utilities, and a responsive layout with a persistent navigation sidebar. The application demonstrates strong engineering practices through its use of TypeScript, strict linting, and well-encapsulated components. Several components, such as the toast notification system, the OpenAI streaming hook, and the form input components, are designed with reusability in mind and could be extracted for use in other projects with minimal modification. The codebase is actively maintained and shows no significant signs of technical debt or dependency decay.
This repository contains a cross-platform mobile application for monitoring Ethereum 2.0 validator performance and machine metrics. Built with Ionic Framework and Angular, it provides a dashboard for tracking validator balances, rewards, effectiveness, and machine resource utilization (CPU, memory, disk, network). The application features integration with the beaconcha.in API for blockchain data, local storage synchronization via a custom Capacitor plugin (storage-mirror), and supports advanced features such as Rocketpool integration, multi-currency display, and configurable notifications. The architecture follows a modular, lazy-loaded pattern with distinct feature modules for validators, dashboard, preferences, and machine monitoring. Notable reusable components include the storage-mirror Capacitor plugin for cross-platform data sharing between the app and home screen widgets, and an InfiniteScrollDataSource utility for efficient paginated data loading using RxJS. The application is actively maintained and demonstrates strong engineering practices in its modular design and separation of concerns. However, the application's reliance on external APIs (beaconcha.in, Firebase, Coinbase, GitHub) and platform-specific native plugins introduces maintenance overhead and potential points of failure. The feature-rich nature of the application also increases complexity, though the core architecture remains sound.
This is a high-quality Android sample application from Nordic Semiconductor that demonstrates Bluetooth Low Energy (BLE) connectivity using the Kotlin BLE Library. The app connects to a peripheral implementing the LED Button Service (LBS), allowing users to toggle an LED and detect button clicks and long presses. It features a modular architecture with separate modules for the device specification (transport-agnostic), BLE transport implementation, UI, and scanner. The app uses Jetpack Compose for UI, Hilt for dependency injection, Navigation 3 for navigation, and a foreground service for background operation. It includes both a native flavor for real BLE hardware and a mock flavor for testing without physical devices. The codebase is well-structured, follows modern Android best practices, and serves as a reference for building BLE apps with the Nordic BLE library.
rules_ios is a Bazel rule set for building Apple platform applications (iOS, macOS, tvOS, watchOS). It provides rules for creating apps, frameworks, extensions, app clips, tests, and handling Apple-specific complexities like code signing, resource bundling, and multi-architecture support. The repository integrates with rules_apple and rules_swift, offering a Bazel-native alternative to Xcode builds. Key features include automatic handling of Apple Silicon compatibility via import_middleman, VFS overlays for faster builds, and comprehensive test generation. The tooling directory contains utilities like arm64-to-sim for running arm64 binaries in x86_64 simulators and SSH password helpers for VM-based testing.
unzip-http is a Python-based command-line tool and library for extracting specific files from a ZIP archive hosted over HTTP without downloading the entire archive. It achieves this by leveraging HTTP range requests to download only the necessary portions of the ZIP file, such as the central directory and the compressed data of individual files. The tool can list the contents of a remote ZIP or extract one or more files (with support for wildcards) to the local filesystem or to stdout. The architecture centers around the `RemoteZipFile` class, which handles the HTTP communication and ZIP file parsing, and the `ZipStream` class, which provides on-the-fly decompression of deflate-compressed data. The CLI entry point in `unzip_http.py` provides a user-friendly interface for common operations, while the same code can be imported and used as a library in other Python programs. The project relies solely on the `urllib3` library for HTTP operations. Two components stand out for their reusability and technical merit: the `ZipStream` class, which implements a streaming decompressor for deflate data that can be used in any context requiring incremental decompression, and the `ZipInfo.parse_extra` method, which robustly handles ZIP64 extra fields to support large files. The project is actively maintained, with recent updates supporting modern Python versions and improving robustness (e.g., better handling of missing Accept-Ranges headers).
Calysto Scheme is a sophisticated Scheme interpreter implemented in Python that integrates with Jupyter notebooks. It features a multi-stage compilation pipeline (CPS → DS → RM → Python) with JIT compilation, continuation support (call/cc), and seamless Python interoperability. The system includes advanced optimizations like persistent vectors for O(1) lexical address lookup, epoch-based cache invalidation, and escape analysis for JIT inlining. It's used in educational contexts and provides debugging tools like a stepper-debugger, making it both a practical development tool and a platform for teaching programming language concepts.
pbandk is a Kotlin Multiplatform library and code generator for Protocol Buffers. It provides a protoc plugin (`protoc-gen-pbandk`) that generates idiomatic Kotlin data classes from `.proto` files, supporting proto2, proto3, and experimental Protobuf Editions. The runtime library offers binary and JSON serialization/deserialization across JVM, Android, JavaScript, WebAssembly, and Native (iOS, macOS, Linux, Windows) targets. The architecture is a classic protobuf toolchain: `.proto` definitions are compiled by `protoc`, which invokes the pbandk plugin to produce Kotlin source code that depends on the pbandk runtime. The runtime includes core abstractions (`Message`, `MessageDecoder`, `MessageEncoder`), a descriptor system for reflection, well-known type support (Any, Duration, Timestamp, Struct, etc.), and configurable JSON encoding. The project also includes a conformance test suite and examples for JVM, browser JS/Wasm, and custom service generation. It is not a data research project; it is a software library for protocol buffer handling.
Matterpoll is a Mattermost plugin that enables users to create and manage polls directly within the chat platform. It provides a slash command (`/poll`) and interactive dialogs for creating polls with options like multi-vote, anonymous voting, progress display, and public add-option. The server-side is written in Go, handling HTTP API endpoints, slash commands, and poll state persistence via Mattermost's KV store. The webapp component, built with React and TypeScript, renders rich poll attachments, a right-hand side card, and handles user interactions. The plugin supports 11 languages via go-i18n and follows Mattermost's plugin development patterns with comprehensive testing and CI/CD. It is a well-structured, production-quality plugin that demonstrates clean separation of concerns, testable interfaces, and localization best practices.
The Network Media Library plugin for WordPress Multisite provides a central media library shared across all sites in the network. It achieves this by designating one site as the central media library and temporarily switching the context to that site during media operations (upload, insertion, editing, etc.). The plugin hooks into numerous WordPress actions and filters to intercept media-related requests and redirect them to the central site. It also includes compatibility layers for popular third-party plugins like Advanced Custom Fields and MultilingualPress to ensure they work correctly with the shared media library. The code is organized into a single main file with several classes encapsulating specific functionalities, such as managing context switches, preserving post thumbnail IDs during save operations, and handling ACF field rendering.