This repository implements a Build Server Protocol (BSP) server that integrates Xcode builds with language servers like sourcekit-lsp. It parses Xcode build logs (either from IDE builds or xcodebuild) to extract compiler flags and serves them via BSP to provide accurate code completion, navigation, and other language features for Swift, C, C++, Objective-C, and Objective-C++ projects. The server operates in two modes: 'xcode' mode automatically monitors build logs via a post-build script or file watching, and 'manual' mode processes build logs on demand. Key components include a robust compilation database handler, a parser for Xcode's proprietary xcactivitylog binary format, and a log parser that handles various Xcode build output formats. The project is actively maintained with recent commits and shows no significant technical debt.
zlFetch is a lightweight JavaScript library that wraps the native Fetch API with quality-of-life improvements. It automatically parses response bodies based on `Content-Type` (JSON, text, form-urlencoded, NDJSON, Blob), provides promise-based error handling that rejects on 4xx/5xx status codes, supports request aborting, and includes shorthand methods for GET, POST, PUT, PATCH, DELETE. The library also offers streaming capabilities (SSE, NDJSON, chunked transfer), an EventSource wrapper for server-sent events, query string helpers, authorization header helpers, and a `createZlFetch` factory for pre-configured instances. The code is modular, well-typed with JSDoc, and thoroughly tested across browser and Node.js environments using vitest.
picosnitch is a Linux daemon for per-executable network bandwidth monitoring using eBPF (CO-RE) and fanotify. It tracks which executables make network connections, records bytes sent/received, timestamps, and metadata (SHA256 hashes, optional VirusTotal and GeoIP lookups). The system provides real-time and historical views via multiple interfaces: a curses TUI (both live top and historical browser), a web UI, and a UNIX socket live feed. The daemon uses a multiprocess architecture with privilege-separated subprocesses for monitoring, event processing, database writes, notifications, and external API queries. It supports local SQLite storage and optional remote SQL (MariaDB/MySQL/PostgreSQL) for tamper-evident logging. The repository also includes a comprehensive comparative benchmark suite (bench/) that tests picosnitch against nine other network monitors across 24 scenarios, with a reusable ToolAdapter framework for running controlled experiments.
vue-cesium is a comprehensive Vue 3 component library that wraps CesiumJS, enabling developers to build 3D geospatial web applications using declarative Vue components. It provides a rich set of components for the Cesium viewer, imagery layers, terrain providers, entities, primitives, geometries, graphics, controls (compass, zoom, navigation, status bar, print), overlays (HTML, heatmap, ECharts, wind, dynamic, typhoon), drawing/measurement tools, analysis features (viewshed, flood), post-process effects, and a full UI kit (buttons, icons, tooltips, sliders, spinners, fab). The library follows a composable-based architecture where each Cesium object type has a corresponding composable managing its lifecycle, prop reactivity, and event bridging. It supports multiple map providers (Baidu, Tianditu, ArcGIS, etc.) with custom coordinate transformations for Chinese coordinate systems. The project is a monorepo with packages for components, composables, shared utilities, locale, theme, and directives. It includes a comprehensive documentation site built with Vitepress featuring live demos and bilingual support (en-US, zh-CN). The codebase demonstrates solid engineering practices with reusable composables, custom material extensions, and a consistent component pattern, though it has some technical debt such as bundled Cesium workers, global Cesium references, and deep watchers that may impact performance with large datasets.
django-auth-adfs is a Django authentication backend that enables integration with Microsoft ADFS and Azure AD for single sign-on (SSO). It implements OAuth2 and OpenID Connect flows to authenticate users against enterprise identity providers, automatically creating and updating Django users based on identity claims. The package provides Django authentication backends, middleware for enforcing authentication, URL handlers for the OAuth2 flow, and Django REST Framework integration for token-based API authentication. The architecture follows Django best practices with clear separation of concerns between configuration, backend logic, views, and middleware.
This repository provides a PHP/Hack library for creating, managing, and deleting temporary directories. The core class `TemporaryDirectory` offers a fluent API to configure directory name, location, permissions, and force creation. It generates unique directory names using timestamps and random numbers, and supports recursive deletion with proper handling of broken symlinks and garbage collection to avoid filesystem locks. The library also includes a destructor-based cleanup mechanism for automatic deletion when the object goes out of scope. The architecture is a single, self-contained class with two custom exception classes for invalid directory names and path conflicts. It relies only on the system's temporary directory and standard filesystem operations, making it lightweight and portable. The code demonstrates attention to edge cases such as trailing slashes, existing directories, and cross-platform path handling. While the syntax is Hack (a PHP dialect with type annotations), the logic is straightforward and could be adapted to other languages. The library is well-tested with PHPUnit and follows semantic versioning with an active changelog.
Merlion is a mature Python library for time series intelligence, specializing in anomaly detection and forecasting. It provides a comprehensive, modular ecosystem including model zoo (classical, tree-based, deep learning, ensemble, AutoML), composable transforms, post-processing chains, evaluation frameworks, and a Dash-based interactive dashboard. The architecture follows a clean layered design: data loading via `ts_datasets`, core `TimeSeries` abstraction, `ModelBase` hierarchy with config-driven instantiation, invertible transforms, and pluggable post-rules. It integrates with Spark for distributed inference and provides benchmarks against standard datasets (NAB, M4, UCR). Though primarily a library (application), it includes research-oriented components such as state-of-the-art transformer architectures (Autoformer, Informer) and Bayesian change point detection, making it a hybrid tool suitable for both production and research.
Your_Spotify is a self-hosted web application that tracks your Spotify listening history and provides a rich dashboard for exploring statistics. It consists of a React frontend (with Redux, MUI, Recharts) and an Express backend (with MongoDB, Mongoose, JWT auth). The system polls Spotify's recently played endpoint every two minutes and also supports importing historical data from Spotify's privacy exports. Users can view top songs, artists, albums, listening time breakdowns, collaborative affinity between users, and create Spotify playlists from their stats. The architecture is a monorepo with two main apps (client and server) deployed via Docker. The codebase is well-structured with clear separation of concerns, reusable UI components, and custom server-side patterns like a queued HTTP client and a write lock mechanism. However, there are no visible tests, and some aggregation pipelines are complex.
This repository is a comprehensive C# library (Ical.Net) for parsing, manipulating, serializing, and evaluating iCalendar (RFC 5545) data. It is a library, not a standalone application, designed to be embedded in calendar and scheduling software. The architecture is centered around a rich domain model (Calendar, CalendarEvent, Todo, Journal, Alarm, VTimeZone) built on top of core data types (CalDateTime, Duration, Period, RecurrenceRule). It features a dual serialization path (a newer CalendarSerializer and an older SimpleDeserializer) and a powerful recurrence rule evaluation engine that handles complex RRULE, RDATE, and EXDATE combinations. Key strengths include its robust timezone handling via NodaTime, a well-designed collection framework (GroupedList, MultiLinkedList), and a pluggable converter system for custom properties. The codebase is heavily tested with hundreds of .ics fixtures and benchmarks, indicating a focus on correctness and performance. While it carries some technical debt from its long history (deprecated APIs, dual serializers), it remains a high-quality, actively maintained implementation of the iCalendar standard.
The stripe/java repository is the official Java client library for the Stripe API, providing type-safe access to Stripe's payment processing and financial services. It features a layered architecture with model classes representing Stripe objects, service classes for API resource access, parameter builders for request configuration, and webhook handling infrastructure. The library supports both legacy static API patterns and a modern instance-based StripeClient entry point, with comprehensive telemetry, expandable fields, and extra parameters for accessing beta features. Code generation from OpenAPI specs ensures consistency with Stripe's API evolution, while hand-crafted components like utility classes and webhook verification demonstrate engineering excellence.
macintosh.js is a desktop application that emulates a 1991 Macintosh Quadra running Mac OS 8 using Electron and a WebAssembly port of the Basilisk II emulator. The architecture consists of three main components: the Electron main process handling application lifecycle and system IPC, the renderer process managing the UI and user input via canvas, and a WebWorker running the emulator core. Communication between threads uses SharedArrayBuffers and Atomics for synchronized access to video, audio, input, and ethernet data. The application provides virtual disk storage through a host folder mapping and basic ethernet networking via UDP broadcast for local AppleTalk communication.
autocannon is a high-performance HTTP/1.1 benchmarking tool written in Node.js, inspired by wrk and wrk2. It operates as both a CLI tool and a programmable library. The architecture is centered around a run loop that manages multiple concurrent HTTP clients, each capable of pipelining requests. Key components include a request builder that constructs raw HTTP request buffers, a pipelined request queue for handling out-of-order responses, and a histogram-based statistics engine using hdr-histogram-js with WebAssembly for efficient percentile calculations. The tool supports HTTPS, Unix sockets, multipart forms, HAR file replay, worker threads for parallel execution, rate limiting with coordinated omission correction, and extensive customization via setup functions and event hooks. The codebase is well-structured with clear separation of concerns, comprehensive test coverage, and active maintenance.
LMFlow is a comprehensive toolkit for fine-tuning, aligning, and deploying large foundation models. It provides a modular library with support for various efficient fine-tuning methods (LoRA, QLoRA, LISA), alignment techniques (DPO, RAFT), and inference backends (vLLM, SGLang). The architecture separates concerns into models, pipelines, optimizers, and utilities, with factory patterns for extensibility. Key features include conversation templating for multiple model families, custom optimizers, and distributed training integration. The toolkit is actively maintained with recent commits and addresses current research in model alignment and efficiency.
This repository contains an Android library for creating additive animations, where multiple animations can be combined by adding their values together rather than having later animations override earlier ones. The library provides a fluent API for animating View properties (position, size, rotation, alpha, etc.) and custom object properties. Key features include physics-based spring animations with configurable stiffness and damping, animation chaining with flexible timing controls, view visibility animations that automatically handle state transitions, and a sophisticated animation state system that determines whether to run animation start/end logic based on the current state of the target object. The implementation stands out for its physics-based spring solver (SpringSolver.kt) which provides an analytical solution to the damped harmonic oscillator equations, handling all damping regimes correctly. The RunningAnimationsManager provides intelligent state management for animations, eliminating common boilerplate for visibility and state-based animations. The library is actively maintained with recent updates, uses current AndroidX dependencies, and follows modern Android development practices with Kotlin coroutines and Java 17 compatibility.
This repository is a Home Assistant custom component that implements a full OpenID Connect (OIDC) Client/Relying Party for authentication. It allows Home Assistant users to log in via an external OIDC Identity Provider (IdP) such as Authentik, Authelia, Keycloak, or any standard OIDC-compliant server. The integration registers a custom auth provider within Home Assistant's auth system, intercepts the default login flow to redirect users to the OIDC provider, and handles the full authorization code flow including PKCE (RFC 7636), ID token validation with configurable signing algorithms, and userinfo retrieval. It supports both public and confidential clients, device code flow for mobile app login, automatic user linking, role-based access mapping from IdP groups, and a multi-step UI configuration wizard for easy setup.
Homer is a production-grade VoIP/SIP telemetry capture, storage, and analytics platform. It ingests HEPv3 packets over UDP/TCP/TLS/HTTP, plus OpenTelemetry traces/metrics/logs and InfluxDB line protocol, decodes SIP and RTCP/VQ-RTCPXR/SIPREC, and stores everything in a DuckDB/DuckLake lakehouse with Parquet files and a SQLite catalog. The system provides tiered hot/cold storage, compaction, retention, time-travel queries, Arrow FlightSQL access for Grafana/BI tools, a REST v4 API, a React dashboard, live WebSocket stream views, a CLI, and a Lua scripting engine for correlation. Although it is fundamentally an operational application, it contains a sophisticated data-lake/ETL layer, so it is hybrid in character; the dominant personality is an application service. The architecture is a modular Go monolith that can run as an all-in-one process or split into writer, node, and coordinator roles via configuration. Ingest listeners feed a zero-copy SIP/HEP decoder into batched DuckLake writers; background compaction and tiering move data across volumes; queries route through an Arrow FlightSQL server or the coordinator's search API. The embedded React/TypeScript UI is extensive, with dashboards, settings, user auth (internal, LDAP, OAuth2), alerting, and even isolated mini-games such as Chess, Tetris, and Doom. External dependencies include DuckDB and its DuckLake extension, S3/Azure object storage, LuaJIT, and optional log shipping to Loki/Elasticsearch. The codebase is well-tested and modular, with several genuinely reusable components such as a zero-copy SIP parser, a generic Go-Lua bridge, a pub/sub broker, and a CIDR-trie alias map. However, there is meaningful technical debt: hand-rolled SQL string interpolation, some duplicate CRUD patterns, a few known failing/skipped tests, pinned DuckDB extension versions, and scope creep from dashboard games. The project is actively developed and the drift is manageable rather than severe.
OpenClaw AWD Arena is a comprehensive platform for conducting Attack-With-Defense (AWD) cybersecurity competitions, specifically designed for training and evaluating large language models (LLMs) in offensive and defensive security scenarios. The system orchestrates isolated Docker container environments where each participant (LLM agent or human) runs a vulnerable service that must be defended while attempting to capture flags from opponents' services. It features a web-based interface for match configuration and real-time monitoring, a Python/FastAPI backend handling game logic, scoring, and WebSocket-based event streaming, and custom orchestration logic for managing the lifecycle of match environments. The platform includes built-in flag management, scoring systems, match replay functionality, and support for multiple agent backends via a plugin architecture.
SpotiFLAC-Mobile is a cross-platform mobile application (Android and iOS) that enables users to download and play high-fidelity music in lossless formats such as FLAC and DSD. It operates through an extension-based architecture where community-provided plugins supply download sources, metadata, lyrics, and cover art. The application integrates with streaming services like Deezer, Tidal, Qobuz, and Spotify via these extensions, handling authentication, rate limiting, and content resolution. The system is built on a multi-language stack: a core Rust backend handles audio processing, metadata tagging, library management, and network communication; a Flutter (Dart) frontend provides the user interface; and platform-specific code in Kotlin (Android) and Swift (iOS) bridges native features like file system access, USB audio output, and system audio routing. The Rust backend is exposed to mobile languages via UniFFI-generated bindings. Key data flows include: extension-based download orchestration with cancellation and progress reporting, audio file finalization (metadata embedding, ReplayGain scanning, cover art insertion), incremental library scanning with SQLite persistence, and multi-provider lyrics fetching with caching. The application also features hi-res audio authenticity verification using STFT analysis, direct USB audio output for bit-perfect playback, and a comprehensive extension management system with sandboxed JavaScript runtimes. External dependencies include FFmpeg for audio conversion, libusb for USB audio transport, and various web APIs (Deezer, MusicBrainz, LRCLib, Apple Music, etc.) for metadata and lyrics enrichment. The project demonstrates strong engineering practices with extensive unit and integration tests, a modular crate architecture, and reusable patterns for cancellation, progress tracking, and caching.
DokuWiki is a mature, open-source PHP wiki engine designed for simplicity and ease of use. It provides a full wiki content management system with features including page creation/editing, revision history, access control lists (ACL), full-text search, media management, RSS/Atom feeds, a plugin system, and multiple authentication backends (plain, LDAP, Active Directory, PDO). The architecture is monolithic but highly modular, with a clear action dispatcher, an event-driven plugin system, a custom parser supporting both native DokuWiki syntax and GitHub Flavored Markdown (GFM), and a template system. Entry points include doku.php (main page request), feed.php, install.php, and various CLI tools (bin/). The codebase is well-structured with namespaced classes, extensive test coverage (PHPUnit), and a strong emphasis on internationalization (over 50 language packs). It is actively maintained with regular commits, CI pipelines, and a large plugin ecosystem.
Image MetaHub is a local-first Electron desktop application for organizing, browsing, and re-generating AI-generated images. It indexes media files in place (no uploads, no moving files) and extracts structured metadata — prompts, models, LoRAs, samplers, seeds, workflows — from 15+ generators including ComfyUI, A1111, InvokeAI, Midjourney, DALL-E, Fooocus, and Adobe Firefly (via C2PA/JUMBF/CBOR parsing). Beyond images it handles video, audio, and 3D model metadata. The app provides tagging, collections, automation rules, ratings, analytics, image comparison with pixel-level diffing, lineage/provenance tracking, and integration with local ComfyUI/A1111 instances for re-generation and upscaling. Pro features (visual search, clustering, batch export) are gated by an offline license system with a 7-day trial and Stripe billing.