slacrawl is a local-first Slack archiving CLI tool written in Go. It ingests messages, files, users, and channels from multiple sources—Slack API (bot/user tokens), Slack Desktop local cache (LevelDB + IndexedDB), MCP (Model Context Protocol) adapters, and external provider subprocesses—and stores them in a local SQLite database with full-text search (FTS5). The tool provides a rich command surface including sync, search, TUI browsing, analytics reports (digest, trends, quiet channels), retention purging, and Git-based archive sharing (publish/subscribe). It is designed for privacy-conscious users who want offline access to their Slack history without cloud dependency. The architecture follows a clean internal package separation: `cmd/slacrawl` is the entry point, `internal/cli` handles command routing via Kong, `internal/store` provides the SQLite persistence layer with schema migrations and batch writes, `internal/syncer` orchestrates multi-source synchronization, and `internal/slackapi`, `internal/slackdesktop`, `internal/slackmcp`, and `internal/provider` implement source-specific adapters. The codebase is well-tested with extensive Go tests, CI/CD via GitHub Actions, and cross-platform releases (Linux, macOS, Docker). While primarily an application, slacrawl exhibits data pipeline characteristics: it ingests raw Slack data, transforms it into a normalized relational schema with FTS indexing, and exposes analytical outputs (reports, digests). The embedding_jobs table hints at future ML integration. The Git archive sharing module is a novel pattern for distributed data replication. Overall, the codebase demonstrates strong engineering practices with reusable components like the generic MCP client, platform-specific file locking, and the external provider protocol.
This repository is a Home Assistant custom component that adds OpenAI-compatible text-to-speech to a HA instance. It is distributed as an integration for HACS and registered as a config-flow service integration. In production it exposes TTS entities, an `openai_tts.say` service that announces text to media players with automatic volume save/restore and optional chimes, and an `openai_tts.set_api_key` service for credential rotation. The architecture is a HA integration split into focused modules: config flow and profile subentries, a streaming TTS engine, a sentence-level audio pipelining layer, an ffmpeg-based loudness pipeline, push-driven API health tracking, cache and validation logic, repairs, diagnostics, and a large announcement orchestration module. Provider support is driven by declarative presets for OpenAI, Mistral, Groq, Lemonfox, Kokoro, Chatterbox, and custom OpenAI-compatible endpoints, and the code intentionally modern-targets HA's streaming TTS contract rather than retaining legacy fallback paths.
virt-v2v is a production-grade virtual machine conversion tool that converts guests from foreign hypervisors (VMware vSphere/ESXi, Xen, Hyper-V, OVA, disk images) to run on KVM/libvirt. It supports multiple input sources (local disk, libvirt-managed guests, OVA archives, VMware VMX, vCenter HTTPS, VDDK, NFC, Xen over SSH) and output targets (local disk, libvirt, QEMU, oVirt/RHV, OpenStack, KubeVirt, VDSM, Glance, null). The conversion process inspects the guest OS (Linux, Windows) using libguestfs, injects virtio drivers for Windows, adjusts boot configuration, remaps block devices and network interfaces, and generates appropriate metadata (OVF, libvirt XML, KubeVirt YAML). It uses nbdkit as a universal disk access layer, enabling parallel copy via nbdcopy and efficient sparse allocation. The codebase is written primarily in OCaml with C stubs and embedded Python scripts for oVirt API interactions. It features a modular architecture with well-defined input/output module signatures, shared library components (NBD_URI, nbdkit wrapper, OVF generation, YAML emitter), and an extensive test suite covering real and phony guest conversions. The project is part of the libguestfs ecosystem and is actively maintained with recent commits, CI/CD via GitHub Actions, and internationalization support.
omni-article-markdown is a CLI tool and library that converts web articles from various sources into clean Markdown format. It employs a modular pipeline architecture: Reader fetches HTML (using requests or Playwright for JavaScript-heavy sites), Extractor isolates article content by removing boilerplate and ads, and Parser converts the cleaned HTML to Markdown with support for code blocks, tables, math equations, and GitHub Gists. The system uses a plugin-based architecture where site-specific readers and extractors are automatically discovered and loaded, allowing easy extension for new websites. Key features include SSL verification control, cookie persistence for sites requiring authentication (like Zhihu), and flexible output options (stdout or file saving).
FlexMeasures is a Flask-based energy flexibility management platform that ingests time-series sensor data, forecasts future values, schedules flexible assets (batteries, heat pumps, industrial processes) using linear optimization, and reports on performance. It provides a REST API (v3.0), a web UI with interactive charts, a CLI for data management, and background job queues (RQ) for forecasting, scheduling, and automation. The architecture is a multi-tenant web application with PostgreSQL, Redis, and optional Sentry monitoring. It features a plugin system for custom data generators (forecasters, schedulers, reporters) and automation handlers. The codebase is well-tested with extensive unit and integration tests, and follows modern Python practices (type hints, Marshmallow schemas, Click CLI).
The official Buildkite CLI (`bk`) is a production-grade Go command-line client for the Buildkite CI/CD platform. It interacts with Buildkite's REST and GraphQL APIs to manage pipelines, agents, builds, jobs, clusters, secrets, teams, and more. The architecture follows a command-pattern with Kong-based parsing, a centralized factory for dependency injection, and a rich set of I/O primitives (spinners, pagers, confirmation prompts) that produce structured output (JSON, YAML, text tables). It includes advanced authentication flows (OAuth device/PKCE), token refresh, keyring-backed credential storage, and self-update capabilities. The codebase demonstrates strong engineering discipline with extensive parallel tests, mock HTTP servers, and a composable error handling framework.
This is a Prometheus exporter for AVM Fritz! home network devices (routers, repeaters, mesh, DECT smart home) that exposes metrics via a TR-064 SOAP API and the AVM AHA HTTP API. Production deployment is a standalone Python service listening on a configurable address:port (default 127.0.0.1:9787) and registering Prometheus metric families (fritz_*). The architecture is a single-process monolith with a clean capability discovery framework: each metric group is defined as a FritzCapability subclass that declares its TR-064 requirements, probes the device at startup, and generates metrics on each scrape. Devices are configured via a YAML file or environment variables, validated through attrs-based data classes. The exporter handles multi-device mesh scenarios, connection timeouts, offline devices with retry logic, and a concurrent scrape lock to avoid deadlocks. It also includes a data donation mode (--donate-data) that collects all available TR-064 actions from a device, sanitizes sensitive fields, and uploads anonymously to a project endpoint — a hybrid feature supporting both operational monitoring and community-driven compatibility research. External dependencies include the fritzconnection library for TR-064, prometheus_client for metric exposition, defusedxml for secure XML parsing, PyYAML for configuration, and requests for HTTP transport.
This repository contains ASFFreeGames, a plugin for ArchiSteamFarm (ASF) that automatically collects free Steam games from Reddit and Redlib sources. The plugin monitors the ASFinfo Reddit user for posts containing "!addlicense asf" commands, extracts game identifiers from these posts, and uses ASF's addlicense command to claim those games for all logged-in bots. It operates on a configurable schedule (default 30 minutes) and can also be triggered manually via the "freegames" command. The architecture follows a plugin pattern with clear separation of concerns: core plugin logic handles ASF integration and scheduling, command processing manages user interactions, strategy objects encapsulate different data source approaches (Reddit vs Redlib), and specialized parsers handle the extraction of game information from HTML/JSON responses. The plugin maintains a persistent cache of already-claimed games to prevent duplicates and supports configuration options for filtering results (e.g., skipping free-to-play games or DLC). Notably, the project contains several high-quality, reusable utility components in the Maxisoft.Utils namespace. These include BitSpan (a high-performance bit array using span<long>), SpanDict (a dictionary implementation using spans with linear probing), OrderedDictionary (a dictionary that preserves insertion order), and RandomUtils (a Gaussian random number generator using the Box-Muller transform). These utilities demonstrate advanced .NET span usage and algorithmic implementation skills, with minimal dependencies making them suitable for extraction to other projects. The project is actively maintained with recent commits, comprehensive CI/CD workflows, and targets the latest .NET 9.0 framework. Dependencies appear current, and the codebase shows no significant technical debt or use of deprecated APIs. The plugin properly handles edge cases like rate limiting, network failures, and invalid responses while providing configurable logging options.
FastCache is a small, high-performance, thread-safe in-memory cache library for .NET 6+. The core is a generic FastCache<TKey, TValue> class built on ConcurrentDictionary, using Environment.TickCount64 for wrap-free expiration timestamps and a shared, lock-throttled background timer to evict expired entries across all cache instances. It provides atomic GetOrAdd with factory arguments to avoid delegate allocations, indexer-based upserts, and an atomic Remove(key, value) operation. The library is distributed as a NuGet package (Jitbit.FastCache) and includes a BenchmarkDotNet project comparing it to MemoryCache and HybridCache, plus a unit test project covering eviction callbacks and cache semantics.
The UTCP-MCP Bridge is a multi-language implementation that exposes Universal Tool Calling Protocol (UTCP) tools as Model Context Protocol (MCP) tools, enabling MCP clients like Claude Desktop to discover and call any UTCP-registered tool. The system consists of MCP servers (in Node.js/TypeScript, Python, Rust, and a web-based implementation) that initialize a UTCP client, register providers from configuration, and expose standard MCP tools for tool management (register/deregister manuals, call tools, search tools, list tools, get tool info, and get required variables). The architecture cleanly separates MCP server concerns from UTCP client operations, with each language implementation following similar patterns but idiomatic to its ecosystem. The bridge handles MCP specification nuances like proper content block preservation for binary data and provides dynamic provider management through REST APIs in the web UI.
This repository provides Python bindings for the BLAKE3 cryptographic hash function, using the official Rust implementation via PyO3. It exposes a single `blake3` class that mimics the Python `hashlib` API, supporting incremental hashing, keyed hashing, key derivation, extendable output (XOF), multithreading via Rayon, and memory-mapped file hashing. The core implementation is in `src/lib.rs`, which demonstrates careful handling of Python buffer protocol types (signed/unsigned bytes), GIL release for long operations, and interior mutability with `Mutex` for thread safety. An experimental C implementation in `c_impl/` provides a fallback for platforms without Rust support. The package is published on PyPI as `blake3` and includes comprehensive test vectors, type stubs, and CI for multiple platforms and Python versions (3.8 to 3.14, including free-threaded).
Red-candle is a Ruby gem that provides bindings to the Hugging Face Candle library, enabling Ruby developers to run state-of-the-art language models directly in Ruby without Python or external APIs. The system supports LLMs (Mistral, Llama, Gemma, etc.), embedding models, rerankers, NER models, and vision-language models with hardware acceleration via Metal (Apple GPU) and CUDA (NVIDIA GPU). The architecture features a clean separation between Ruby interface layer and Rust extension. The Ruby layer provides idiomatic APIs (Candle::LLM, Candle::EmbeddingModel, etc.) while the Rust extension handles model loading, tensor operations, and hardware-specific computations using the Candle ML library. Key design patterns include unified model loading via `from_pretrained`, device abstraction for CPU/GPU selection, tokenizer access across all models, structured generation with JSON schema constraints, and a complete tool calling framework with agent capabilities. The project demonstrates strong engineering practices with comprehensive test coverage, extensive examples showing real-world usage (biomedical NER, chat interfaces, reranker benchmarks), and clear documentation. It successfully bridges the Ruby and Rust ecosystems while maintaining performance and usability, making advanced AI accessible to Ruby developers through a consistent, well-abstracted interface.
min-dl is a minimal ELF dynamic linker implementation that loads shared libraries, performs relocations, resolves symbols, and runs init/fini constructors without depending on glibc's ld-linux runtime. The codebase provides a clean API (lib-support.h) for loading ELF objects, symbol lookup, PLT resolution, and constructor/destructor execution. It supports multiple architectures (x86_64, ARM, AArch64, RISC-V) through architecture-specific headers and includes a comprehensive test suite validating functionality across platforms. The implementation demonstrates strong engineering practices in ELF parsing, memory management, error handling, and cross-platform support.
Modern Industrialization is a comprehensive tech mod for Minecraft (NeoForge) that introduces a progressive automation system. It adds hundreds of machines, multiblocks, pipes, energy networks, and a full nuclear reactor simulation, all driven by a data-driven material and recipe system. The mod features a component-based machine architecture where each block entity is composed of modular NBT-serializable components with client-server sync, a custom vendored Fabric Transfer API for fluid/item storage with transactional rollback, and a sophisticated pipe network manager for item, fluid, and energy transport. It includes extensive compatibility layers for KubeJS scripting, JEI/REI/EMI recipe viewing, AE2 integration, Jade tooltips, and Sodium/Embeddium performance optimizations. The codebase is large but well-structured, with procedural texture generation, runtime datagen, and a robust multiblock shape matching system. It demonstrates strong engineering practices in mod development, particularly in its component abstraction, network management, and transactional resource handling.
DCS Scratchpad is a Lua-based mod for Eagle Dynamics' DCS World flight simulator that provides an in-game, resizable, and movable scratchpad for taking persistent notes. The mod allows users to create and switch between multiple text pages, insert coordinates from the F10 map interface, and persist all notes to text files in the user's saved games directory. It integrates with DCS World through Lua simulation callbacks to manage the UI state and handle user interactions. The mod features an extension system that enables additional functionality such as virtual keyboards, aircraft-specific startup procedures, message logging, and coordinate formatting tools. Extensions are loaded from Lua files in a designated directory and receive a well-defined API for interacting with the scratchpad UI, including adding buttons, registering coordinate listeners, and manipulating text content. This architecture allows for community-contributed enhancements while maintaining core functionality. Key technical highlights include robust UTF-8-aware text manipulation for proper cursor positioning and text insertion, sophisticated geographic coordinate formatting supporting multiple representations (DMS, DDM, Decimal Degrees), and a sandboxed extension loading mechanism that provides isolation between extensions and the core mod. The implementation demonstrates attention to detail in handling edge cases related to international text, coordinate systems, and user interface interactions.
This repository is an antivirus evasion toolkit designed to help bypass security detection through various techniques. It provides tools to encrypt shellcode using XOR and Base64 encoding, along with loaders that decrypt and execute the payload in memory while implementing anti-analysis checks. The toolkit has evolved over time with versions in C, Nim, and C++, showing progressively more sophisticated evasion techniques including API hooking, memory patching, string obfuscation, and cryptographic payload protection. The code demonstrates understanding of Windows internals and offensive security techniques.
Beaneater is a Ruby client library for the beanstalkd work queue. It provides a simple, thread-safe interface to interact with beanstalkd servers, enabling job enqueuing, reservation, and management through tubes (queues). The library handles connection management with automatic retry and reconnection logic, supports job lifecycle operations (delete, bury, release, etc.), and includes a processor registration system for automated job handling with retry and error recovery. Communication with beanstalkd occurs via the native TCP protocol, and the library translates responses into Ruby objects using optimized struct conversions. Key features include timeout configuration, tube watching/waiting, and statistics introspection.
hastscript is a utility for creating Hast (HTML Abstract Syntax Tree) trees using a hyperscript-like API. It provides two main functions, `h` for HTML and `s` for SVG, which accept CSS-like selectors, properties, and children to construct virtual DOM nodes. The library is designed to be used in build tools and frameworks that work with the Hast syntax tree, such as those in the Unified collective. The core of the library is the `createH` function in `lib/create-h.js`, which is a parameterized hyperscript function that can be adapted for different domains (like HTML or SVG) by providing a schema and default tag name. Additionally, the library supports JSX via automatic and classic runtimes, implemented in `lib/create-automatic-runtime.js` and wired up in `lib/index.js`. The project is well-maintained, with recent commits and active CI workflows, and shows low technical drift with up-to-date dependencies.
ircd-hybrid is a high-performance, modular IRC daemon written in C. It implements the full IRC protocol (RFC 1459, 2812, 2813) with modern IRCv3 capabilities (account-notify, extended-join, etc.), server-to-server linking (TS6), TLS support (GnuTLS, OpenSSL, wolfSSL), and a dynamic module system via GNU libltdl. The architecture is event-driven with selectable I/O backends (epoll, kqueue, poll) and a self-contained I/O abstraction library (libio) that provides networking, DNS resolution, event timers, data structures (patricia trie, doubly-linked lists, dynamic buffers), and TLS abstraction. Configuration is parsed by a Bison/Flex-generated parser supporting a rich set of server options. The codebase is well-structured with a clear separation between core daemon, library, and loadable modules, making it extensible and maintainable. Originally forked from the hybrid IRCD project in 1997, it has evolved to support modern IRC standards while maintaining backwards compatibility.
Mentoss is a utility library for mocking JavaScript fetch() requests and responses in testing environments. It provides three primary classes: MockServer for defining request/response routes, FetchMocker for creating mocked fetch functions that work with one or more MockServers, and MockAgent for undici Dispatcher support in Node.js environments. The library handles complex HTTP features including CORS, credentials, redirects, and various request matching scenarios (URL parameters, headers, body content). The architecture is modular and well-separated, with distinct responsibilities for route matching (request-matcher.js), CORS handling (cors.js), cookie management (cookie-credentials.js), and request/response processing. Each MockServer instance maintains its own route registry and tracks which routes have been called, enabling precise test assertions. The FetchMocker coordinates multiple servers and handles cross-origin requests with proper CORS preflighting and credential attachment. Mentoss is designed for use in test suites where developers need to simulate HTTP interactions without making actual network calls. It supports both browser-like fetch() behavior (with baseUrl and credentials options) and Node.js undici/fetch() usage (via MockAgent). The library includes comprehensive testing helpers to verify which routes were called, assert all routes were exercised, and diagnose mismatched requests through detailed tracing.