This repository is a zero-dependency JavaScript library for detecting 18 candlestick patterns (29 variants) in financial OHLC data. It provides a consistent API per pattern (boolean check and array scanner), a multi-pattern scanner with optional trend context for confidence adjustment, a streaming API for memory-efficient processing of large datasets, a plugin system for custom patterns, and a CLI tool for quick analysis. The library supports both CommonJS and ES Modules, includes TypeScript definitions, and is extensively tested with unit, integration, and property-based tests. It is designed for use in trading systems, backtesting, and algorithmic trading applications.
The repository is a data pipeline that generates Shadowrocket configuration files for selective traffic routing, particularly targeting users in Russia who need to bypass censorship while maintaining access to local services. It automates the collection, processing, and formatting of domain and IP lists from various sources into Shadowrocket-compatible rule sets and configuration files. The pipeline fetches data from diverse sources including GitHub repositories, websites (like the Central Bank of Russia), and manually curated lists. It then processes this data through a series of transformations: filtering, formatting, IDN conversion, section-based processing, and DNS resolution, to produce standardized output files that adhere to Shadowrocket's rule syntax. The processed data is used to generate configuration files that define which traffic should go through proxies and which should connect directly. Key reusable components within the pipeline include an IDN decoding script that properly handles internationalized domain names by detecting non-ASCII characters and converting to punycode while preserving original formatting, and a section-based list processor that applies different transformations to file segments based on markers. These components demonstrate non-obvious skill in handling specific data challenges and follow patterns that could be extracted for use in other data processing projects. The pipeline is executed on a daily schedule via GitHub Actions, ensuring the generated configuration files remain up-to-date with the latest domain and IP information from the source feeds. This automation allows users to benefit from continuously improved routing rules without manual intervention.
NeoCodeium is a Neovim plugin that provides AI-powered code completion using the Windsurf (formerly Codeium) service. It features a modular architecture with separate modules for state management, completion logic, rendering, server communication, and utility functions. The plugin integrates with Neovim's autocommands to provide real-time suggestions as virtual text, supports cycling through completions, accepting partial suggestions, and includes a chat interface via the Windsurf service. It is designed to be highly configurable and works alongside other completion plugins like nvim-cmp and blink.cmp.
This monorepo provides a comprehensive TypeScript SDK for the AT Protocol (Bluesky), including client libraries, server frameworks, OAuth authentication, identity resolution, data serialization (CBOR, CAR, CID), and lexicon-driven code generation. The architecture is modular, with ~50 packages organized by domain (clients, servers, utilities, definitions, OAuth, identity, bluesky-specific features). Key entry points include the generic XRPC client (`@atcute/client`), the OAuth browser and node clients, the XRPC server framework with WebSocket support, and the lexicon CLI for generating TypeScript bindings from AT Protocol schema definitions. Data flows involve typed API calls over HTTP/WebSocket, with automatic validation, rate limiting, and caching. External dependencies include `valibot` for runtime validation, `@noble/curves` for cryptography, and platform-specific WebSocket/Fetch implementations.
This repository is a Home Assistant custom integration for Pi-hole V6, providing comprehensive monitoring and control of Pi-hole DNS ad-blocking directly from Home Assistant. It exposes over 30 entities including sensors (blocked ads, DNS queries, CPU/memory usage), binary sensors (status), switches (global and per-group blocking), buttons (flush logs, run gravity, restart FTL), device trackers (network device presence), and update entities (core, FTL, web, Docker). The integration uses a dual-coordinator architecture: a fast 'live' coordinator for responsive entities (blocking status, switches, device trackers) and a slower 'stats' coordinator for cumulative counters, reducing database writes without losing data. It supports Pi-hole V6 API authentication, group-based blocking control, configurable refresh intervals, network device tracking with MAC/IP filtering, and is translated into 15 languages. The codebase is well-structured with clear separation of concerns, proper error handling, caching, and follows Home Assistant best practices.
TopNotify is a Windows application that allows users to customize how notifications appear and behave on their desktop. The system consists of a background daemon service that intercepts Windows notifications and modifies their presentation based on user preferences, combined with a system tray-accessible GUI built with React/Vite for configuration. The architecture cleanly separates concerns: the daemon handles notification interception and modification using Windows APIs, while the GUI provides user configuration. Communication between components occurs via mailslots for IPC and a shared JSON settings file. The application employs an interceptor pattern where different aspects of notification handling (positioning, sound, text-to-speech) are implemented as pluggable components. Key technical highlights include native C++ code for enumerating Windows notification windows, sophisticated DPI-aware multi-monitor positioning logic, and a clean plugin architecture for notification interceptors. The application is packaged as an MSIX installer with support for both x64 and ARM64 architectures.
envrc.el is an Emacs Lisp package that provides buffer-local environment variable management using the direnv tool. It implements a global minor mode (`envrc-global-mode`) that enables a local minor mode (`envrc-mode`) in every buffer, which sets buffer-local `process-environment`, `exec-path`, and related variables based on the nearest `.envrc` file. The package caches direnv results per directory, supports asynchronous direnv execution with configurable blocking behavior, and advises several Emacs shell commands (e.g., `shell-command`, `async-shell-command`, `org-babel-eval`) to propagate the local environment into temporary buffers. It also includes TRAMP support for remote files, a major mode for editing `.envrc` files, and a comprehensive test suite. The architecture is a single-file Emacs package with clean separation of concerns: environment detection, direnv process management, result caching, and application to buffer-local state. The code demonstrates advanced Emacs Lisp patterns including minor modes, process filters and sentinels, advice, and buffer-local variable management.
grblHAL/core is an embedded firmware for real-time CNC motion control, derived from the original grbl 1.1f project. It interprets G-code (RS274/NGC) and executes motion planning with acceleration/jerk profiles, driving stepper motors via a hardware abstraction layer (HAL) that supports many 32-bit MCUs (ESP32, STM32, RP2040, i.MX RT, etc.). The architecture is modular: a plugin system allows adding spindles, I/O expanders, kinematics (CoreXY, delta, polar, wall plotter), networking, and custom M-codes. Key subsystems include a G-code parser, motion planner with look-ahead, stepper ISR with Bresenham and AMASS, state machine, settings registry with NVS persistence, virtual file system, and cooperative task scheduler. Communication streams (serial, TCP, WebSocket, Modbus) are multiplexed. The codebase is highly optimized for real-time constraints, uses extensive conditional compilation for configurability, and provides reusable patterns such as function-pointer-based HAL, callback chaining, and abstracted I/O. While some internal coupling exists, many modules (crc, regex, utf8, string utilities, PID, expression evaluator, task scheduler) are self-contained and extractable.
Uno is a modular C++ solver for nonlinearly constrained optimization (NLP, QP, LP). It implements a unification framework that combines interchangeable algorithmic ingredients—constraint relaxation strategies, inequality handling methods, Hessian models (exact, quasi-Newton, identity, zero), inertia correction, subproblem solvers (QP/LP), and globalization mechanisms (line search, trust region, filter, funnel). The solver supports both sequential quadratic programming (SQP) and interior-point methods, and can be configured via presets that mimic established solvers like filterSQP and IPOPT. The architecture is a library with a main orchestration loop in `Uno.cpp`. The user defines the optimization problem through callback functions (objective, gradient, Jacobian, Hessian) via a C API, which is then wrapped by interfaces for AMPL, Fortran, Julia, and Python. Internally, the solver builds a regularized KKT system, delegates subproblem solves to external libraries (HiGHS, BQPD, HSL MA27/57/86, MUMPS, SPRAL), and applies globalization to ensure convergence. The codebase is heavily templated and uses expression templates for linear algebra, factory patterns for component selection, and runtime dynamic loading for optional dependencies. Key entry points include `uno_optimize()` (C API), `UnoSolverWrapper::optimize()` (Python), and the AMPL executable `uno_ampl`. The solver is used in research and production environments via JuMP.jl, CasADi, pyOptSparse, and OpenMDAO. External dependencies include BLAS/LAPACK, HSL (proprietary), MUMPS, SPRAL, HiGHS, BQPD, and AMPL ASL. The project is actively maintained with extensive CI, cross-platform builds, and a growing ecosystem of language bindings.
This repository is an ESLint plugin for the Vitest testing framework, providing over 60 lint rules to enforce best practices, catch common errors, and maintain code style in test files. It is a library consumed by ESLint, not a standalone application. The plugin exports a flat config (recommended, all) and an environment configuration for Vitest globals. The codebase is well-structured with a consistent rule creation pattern using a factory utility (`createEslintRule`), centralized Vitest function call parsing (`parseVitestFnCall`), and a reusable padding rule factory (`createPaddingRule`). It relies on `@typescript-eslint/utils` for AST analysis and is designed for ESLint v9+ with flat config. The project is actively maintained with CI/CD, automated releases, and comprehensive test coverage for each rule.
CodeGraph is a Python command-line tool that performs static analysis on Python source code to generate dependency graphs. It parses Python files to extract functions, classes, and import statements, then builds a graph showing how these entities depend on each other. The tool outputs an interactive HTML visualization (using D3.js by default) or can export the data to CSV or print it to the console. The architecture is modular, consisting of a parser (using Python's tokenize module), a core module that builds the dependency graph, utility functions for file discovery, and a visualizer that supports both D3.js (interactive) and matplotlib (legacy) backends. The tool does not execute the code being analyzed, making it safe and fast for large codebases. Key strengths include a robust parser that handles various import styles and class inheritance, and a flexible visualization system that provides features like search, collapsing/expanding nodes, and detailed tooltips. The project is actively maintained with comprehensive tests and supports multiple Python versions.
tsify is a Rust library that generates TypeScript type declarations from Rust types, primarily for the wasm-bindgen ecosystem. The core mechanism is a `#[derive(Tsify)]` proc macro that produces a `Tsify` trait impl whose `DECL` constant is emitted into the wasm-bindgen `typescript_custom_section`, so `wasm-pack` automatically appends the generated `.d.ts` alongside the JS output. It maps Rust structs, enums, and type aliases to TypeScript interfaces, type aliases, namespaces, and unions, respecting serde attributes (`rename`, `tag`, `untagged`, `flatten`, `skip`, `default`, `transparent`) and offering tsify-specific overrides (`type`, `type_params`, `type_prefix`/`type_suffix`, `rename`, `namespace`, and serializer options like `missing_as_null` / `hashmap_as_object` / `large_number_types_as_bigints`). A second runtime type, `Ts<T>`, provides a memory-safe alternative to the deprecated `into_wasm_abi`/`from_wasm_abi` attributes by deferring deserialization out of the infallible ABI boundary into the function body, avoiding the destructor-skipping `throw_str` leak path.
CacheControl is a Python library that adds HTTP caching to the popular `requests` library. It ports the caching algorithms from httplib2, providing a transparent caching layer for HTTP sessions. The library intercepts HTTP requests and responses, caching responses based on standard HTTP caching headers (Cache-Control, Expires, ETag) and optional heuristic rules. It supports multiple cache backends including in-memory dictionary, file-based cache (with separate body storage for memory efficiency), and Redis. The architecture is modular: a `CacheController` implements the core caching logic (freshness calculation, conditional requests, cache invalidation), while `CacheControlAdapter` integrates with requests' transport adapter system. The library also provides a CLI tool (`doesitcache`) for testing caching behavior. It is well-tested, type-annotated, and follows modern Python packaging practices.
This repository is the GNUstep Objective-C runtime library (libobjc2), a drop-in replacement for the GCC Objective-C runtime that implements the modern Objective-C runtime API for non-Apple platforms. It provides the core runtime services: message dispatch (via architecture-specific assembly fast paths and a C fallback), memory management (ARC retain/release, autorelease pools, weak references), block support, property access, exception handling (with C++ interop), and type-dependent dispatch. The architecture is a shared library with a modular design: loader.c handles module loading, selector_table.cc manages selector uniquing, class_table.c manages class loading and +load, sendmsg2.c implements message lookup, and arc.mm implements the ARC contract. It supports three ABIs (GCC legacy, GNUstep v1 non-fragile, GNUstep v2 modern) and runs on Linux, Windows, FreeBSD, Android, and WebAssembly. The codebase is well-structured with several reusable data structures (hopscotch hash tables, sparse arrays, platform-abstracted locks) and demonstrates strong engineering practices in performance-critical paths (cache-line alignment, atomic operations, copy-on-write dispatch tables). However, it carries significant complexity from legacy ABI compatibility and platform-specific ifdefs, and some components (C++ exception interop) rely on fragile runtime structure discovery.
SwiftNIO HTTP/2 is a Swift library providing HTTP/2 protocol support for SwiftNIO-based applications. It implements the HTTP/2 specification (RFC 7540) and HPACK header compression (RFC 7541) in pure Swift, with no external dependencies beyond SwiftNIO core. The library features a modular architecture separating frame handling, connection state management, stream multiplexing, and header compression. Key components include a connection state machine for managing HTTP/2 connection lifecycle, stream multiplexing logic for creating child channels per HTTP/2 stream, and an HPACK implementation with Huffman coding. The repository includes extensive unit tests, integration tests, performance benchmarks, and fuzz testing to ensure correctness and performance.
This repository contains the FreeType 2 library, a portable font rendering engine that provides high-quality glyph rendering for multiple font formats (TrueType, Type 1, OpenType, etc.). The library is designed as a modular, extensible system with a plugin architecture for drivers and renderers, featuring a stream abstraction for input handling and a generic glyph object for unified glyph manipulation. It supports advanced features including subpixel rendering, color fonts (SVG, COLR), variable fonts, and LCD filtering. The library is intended for integration into applications requiring text rendering, such as GUI toolkits, document viewers, and graphic design software, and does not include text layout capabilities (requiring external libraries like HarfBuzz for shaping).
Mule is a lightweight integration platform (iPaaS) for connecting systems, avoiding point-to-point integrations by managing message-routing, data mapping, orchestration, reliability, security, and scalability. The architecture centers around 'flows' composed of Lego-block-like message processors for receiving, transforming, and processing messages, triggered by external events (e.g., consumer requests, database changes). It supports deployment on-premise, cloud, or various application servers. The system is a modular framework with a core runtime and extension system, where applications are built by composing flows using various components (connectors, transformers, processors). Key entry points include the standalone runtime CLI (`./bin/mule`), IDE integration (Anypoint Studio), and programmatic use via MuleContext API. Primary data flows involve messages traversing processors in a flow: [Message Source] -> [Processors (transformers, components, etc.)] -> [Message Destination]. External dependencies include Java, Spring (though evolving away), Project Reactor (reactive streams), SLF4J (logging), Netty (HTTP), and DataWeave (transformation).
This repository provides a PyTorch implementation of Slot Attention and its variants for object-centric learning. The core SlotAttention module refines a set of slot representations via iterative attention from slots to inputs, enabling the model to discover and represent objects in a scene. The repository extends this base with several wrappers: MultiHeadSlotAttention for multi-head attention, AdaptiveSlotWrapper for dynamic slot selection via Gumbel softmax, MetaSlotAttention for deduplication using vector quantization, and OrthoSlotWrapper for adding an orthogonality loss to encourage distinct slot representations. The library is designed to be modular and reusable, with each component having minimal dependencies and clear interfaces. The code leverages einops for readable tensor operations and follows modern PyTorch practices. A training script is included to demonstrate the usage on a toy dataset of colored rectangles, showing how the slot attention can be used to discover and deduplicate objects. The project is actively maintained, with recent commits and a healthy number of stars and forks. Dependencies are well-specified and up-to-date, indicating low technical drift. The codebase exhibits strong craftsmanship in its clean abstractions and reusable components, making it a valuable resource for researchers and practitioners working on object-centric representations.
Suwayomi-JUI is a multiplatform manga reader application built with Kotlin Multiplatform, targeting Android, Desktop, and iOS. It functions as a client for the Suwayomi-Server backend, communicating via GraphQL (Apollo) and REST (Ktor) to manage a personal manga library, download content for offline reading, and provide a customizable reading experience. The architecture follows a clean layered structure: core utilities, data layer (repositories and network clients), domain layer (business logic and use cases), and presentation layer (UI with Jetpack Compose/SwiftUI). Key features include library management with categorization, extension/plugin support, download queue management, reading interface with various navigation modes, backup/restore functionality, and comprehensive settings. The application employs dependency injection via custom annotations, reactive programming with Kotlin Flows and coroutines, and a cross-platform preference storage system. It is actively maintained with recent commits and demonstrates strong engineering practices in modularity and platform abstraction.
Activitypub-federation is a high-level Rust framework for implementing ActivityPub federation. It provides abstractions for handling incoming and outgoing activities, fetching remote objects, managing HTTP signatures, and integrating with web frameworks like Actix-web and Axum. The library uses a trait-based design where users define their own data structures and implement Object, Activity, and Actor traits to plug into the federation system. It includes sophisticated features like an activity queue with exponential backoff retry logic (1 minute, 1 hour, 2.5 days), automatic caching of remote objects, and comprehensive security measures including HTTP signature verification.