Gabagool is a Python-based arbitrage trading bot for Polymarket's 15-minute prediction markets, with performance-critical components implemented in Rust via PyO3 extensions. The bot implements the 'Gabagool arbitrage' strategy: buying both YES and NO shares when their combined cost is less than $1.00 to guarantee profit regardless of market outcome. The architecture features a modular design separating concerns into API clients (Gamma and CLOB), trading strategy, position tracking, risk management, and persistence layers. Key components include a thread-local HTTP session manager to prevent connection pool issues, a SQLite-based persistence layer for trade and position data, and a thread-safe position tracker with expiration mechanisms. The system supports multiple operational modes including live trading, paper trading simulation, and backtesting against historical data. Recent development activity shows active maintenance with ongoing Rust integration for performance optimization.
This repository is a control system for AlfaZeta FlipDot display panels, electromagnetic dot matrix displays that physically flip dots to show images. It provides both Processing (Java) and Node.js implementations that convert image data to the specific binary format required by the displays and transmit it via serial/USB or Ethernet connections. The system includes a virtual display buffer for drawing animations and games, with examples like Tetris, clock effects, and procedural visualizations. When no physical hardware is connected, it operates as a simulator. The architecture separates core display logic, hardware communication, configuration, and example content into modular components.
This repository contains a full-stack web application deployed on AWS ECS with a CI/CD pipeline. The frontend is a Vue.js application that retrieves product data from a backend Node.js/Express API. The backend scans a DynamoDB table and returns product information, including image URLs stored in S3. Infrastructure is provisioned via Terraform, including networking, ECS cluster/services, ECR repositories, IAM roles, CodePipeline/CodeBuild/CodeDeploy for Blue/Green deployments, autoscaling, and supporting resources (S3, DynamoDB, SNS). The architecture separates concerns with modular Terraform modules and implements production-grade practices like health checks, Swagger documentation, and stress testing.
This repository provides C# bindings for the SDL3 multimedia library through automated code generation. It processes SDL3 C headers via the c2ffi tool to produce an intermediate JSON representation, then applies user-provided overrides to generate idiomatic C# P/Invoke wrappers. The output includes two variants: SDL3.Legacy.cs targeting .NET Framework using DllImport with manual string marshaling, and SDL3.Core.cs targeting .NET 8+ using LibraryImport with custom marshallers for improved safety and performance. The bindings enable .NET applications to access SDL3's graphics, audio, input, GPU, and system functionality. While the generator is highly specialized for SDL3, it demonstrates sophisticated patterns in type resolution, struct layout handling, and marshaling strategy selection that could inform similar binding projects.
Cell-ACDC is a desktop GUI application for bioimage time-lapse analysis, purpose-built for cell segmentation, tracking, and cell cycle annotation in live-cell imaging data. The application is built on PyQt5/PyQt6 with pyqtgraph for visualization, and exposes both a full graphical interface and a headless CLI mode via console entry points (`cellacdc`, `acdc`, `Cell-ACDC`). It includes Fiji/ImageJ macros for converting raw microscopy files into the expected folder structure, Cython-accelerated extensions for performance, and a QObject-based worker/signal architecture for running long segmentation and tracking tasks asynchronously with progress reporting and pause/resume control. The codebase is organized around a monolithic `dataPrepWin` GUI class that mixes UI construction, file I/O, worker management, and domain logic, alongside more modular components: `core.py` provides image-analysis and segmentation post-processing helpers (nearest-point matching, convex-hull calculations, label filtering), `whitelist.py` implements an ID filtering mechanism with original label preservation, and `workers.py` defines ~30 reusable signals for progress, error handling, and task control. The application depends on external tools including Java (for some segmentation plugins), PyTorch (for deep-learning-based segmentation), and a rigid folder structure with hardcoded paths. The repository shows active maintenance with CI workflows for both PyQt5 and PyQt6, Cython build automation, and issue templates. However, it exhibits technical drift: a deprecated PyTorch conda channel is referenced, Java version compatibility issues exist, and the dual Qt5/Qt6 support increases test surface. The codebase has moderate coupling and hardcoded settings (e.g., `QSettings('schmollerlab', 'acdc_dataPrep')`), but the core algorithmic components are sufficiently isolated for reuse in other bioimage analysis pipelines.
This repository is a community-maintained interactive web map for Red Dead Online (RDO), built as a single-page application using Leaflet. It provides players with a comprehensive overlay of in-game locations, including collectibles, animals, plants, shops, hideouts, random encounters, legendary animal spawns, free roam events, and daily challenges. The application is entirely client-side, loading static JSON data files and rendering markers on a Leaflet map with custom styling, clustering, and heatmaps. It features a rich side menu for filtering, a settings panel with localStorage persistence, user-customizable pins, and a localization system supporting over 30 languages via Crowdin. The architecture is modular, with separate JavaScript files for each map category (e.g., animals.js, plants.js, bounties.js) and utility modules for settings, language, and data loading. External dependencies include Leaflet, Bootstrap, Tippy, and several Leaflet plugins, all loaded via CDN or vendored copies. The repository also contains development scripts for extracting game data from binary files and generating route optimization algorithms. While primarily an application, it has a strong data component with curated JSON datasets that must be manually updated when the game changes.
Healenium-web is a self-healing library for Selenium WebDriver-based tests. It wraps standard WebDriver instances in a SelfHealingDriver proxy that intercepts element lookup calls and attempts to heal failed locators by finding alternative strategies when elements aren't found. The architecture uses a chain of responsibility pattern with specialized processors for finding elements, retrieving reference data from a backend service, healing elements through various selector strategies, and saving results. The system communicates with a backend service (hlm-backend) to store and retrieve element metadata, enabling intelligent locator recovery across test runs.
secretgen-controller is a Kubernetes operator that automates the generation and sharing of secrets within a cluster. It defines custom resources (Certificate, Password, RSAKey, SSHKey) that produce corresponding Kubernetes secrets, and provides cross-namespace secret export/import via SecretExport and SecretImport CRDs. Additionally, a SecretTemplate CRD allows constructing secrets from data in arbitrary Kubernetes resources using JSONPath expressions. The controller is part of the Carvel tool suite and is built with controller-runtime, using generated clientsets and informers for both the original secretgen.k14s.io API group and the newer secretgen.carvel.dev group. The architecture follows the standard Kubernetes operator pattern: a single controller binary (cmd/controller/main.go) registers multiple reconcilers for each CRD, plus a SecretReconciler that handles image pull secret merging from exported secrets. Reconcilers use a thread-safe tracker to watch input resources and a generic status helper to update conditions. Secret generation relies on the cloudfoundry/config-server library for cryptographic operations, with FIPS 140-3 support added for SSH key fingerprints and certificate SubjectKeyId. The sharing subsystem maintains an in-memory cache of secret exports with sorting and weight logic to resolve conflicts. The codebase is well-structured with clear separation of concerns, comprehensive end-to-end tests, and a robust CI/CD pipeline. However, it carries some technical debt: two API groups that may diverge, heavy reliance on code generation, and potential performance issues from listing all resources on every relevant event. The use of panic statements in shared code and the custom fork of cloudfoundry/config-server introduce maintenance risks. Overall, it is a production-grade operator suitable for managing secrets in Kubernetes environments.
mpiFileUtils is a suite of MPI-based command-line tools for managing large datasets on parallel file systems (Lustre, DAOS, GPFS, NFS). It provides parallel equivalents of common file operations: dcp (copy), dsync (sync), drm (remove), dcmp (compare), dtar (archive), dfind (find), dchmod (chmod), dbcast (broadcast), ddup (dedup), and others. The tools are built atop a common library (libmfu) that implements a distributed file list (mfu_flist) with collective operations, path manipulation, I/O wrappers with retry logic, progress reporting, and work distribution via libcircle. The architecture follows a walk->filter->act pattern where the file system is traversed in parallel, metadata is aggregated into a distributed list, and work is distributed across MPI ranks. The tools are designed for high-throughput operations on millions of files and are used in HPC environments. While the codebase shows signs of legacy (dcp1, Python 2 tests), it is actively maintained and includes advanced features like DAOS object-level copy and tar indexing for parallel extraction. The repository is primarily an application (CLI tool suite) with a strong library component (libmfu) that could be reused in other HPC data-movement projects.
threeify is a TypeScript monorepo providing a WebGL2-based 3D rendering library with a focus on physically-based rendering (PBR), glTF support, and modular architecture. It is loosely derived from three.js but aims for a more modern, tree-shakeable design with native WebGL2 abstractions. The library includes a comprehensive math package (vectors, matrices, quaternions, colors, bounding volumes), a scene graph with cameras, lights, and materials (including clearcoat, sheen, transmission, and anisotropic extensions), a renderer with post-processing effects (tone mapping, Gaussian blur, bloom, cubemap background), a 2D layer compositor with blend modes and panorama support, and a custom GLSL-to-TypeScript transpiler for shader management. The codebase is organized into packages (core, math, scene, layer-compositor) and tools, with over 50 interactive examples demonstrating various rendering techniques. External dependencies include WebGL2 and browser APIs; the library is still in development and not yet recommended for production use.
term39 is a cross-platform terminal multiplexer and emulator built in Rust, featuring a retro MS-DOS aesthetic. It provides a full-screen text interface with window management (drag, resize, minimize, maximize, auto-tiling), terminal emulation via VTE ANSI parsing and PTY integration, session persistence through a Unix daemon, a lockscreen with OS-level authentication (PAM, macOS DS, Windows Security, PIN), and an optional Linux framebuffer backend for direct console rendering. The application supports multiple platforms including Linux, macOS, Windows, FreeBSD, NetBSD, OpenBSD, and Android/Termux, with feature-gated builds via Cargo features. The architecture is modular: an event loop drives input handling (keyboard, mouse) and rendering through a `RenderBackend` trait that abstracts terminal (crossterm) and framebuffer backends. The UI is composed of widgets (top bar, battery, network, system menu) and dialogs (config, prompt, toast, info). Terminal state is managed by `TerminalGrid` and `TerminalEmulator`, with ANSI escape sequences parsed by `AnsiHandler`. Session persistence uses a client/daemon pattern over Unix domain sockets, allowing windows to be detached and reattached. The lockscreen supports multiple authentication backends via a factory pattern. While the codebase is feature-rich and well-structured in many areas, it exhibits some technical drift: dead code artifacts (e.g., a disabled restore line in main.rs), heavy use of `#[allow(dead_code)]`, platform-specific code duplication, and unsafe operations in forking and signal handling. The rapid version history (0.1.0 to 1.6.0 in about a year) suggests fast iteration, which may have introduced some technical debt. Nonetheless, the project demonstrates strong engineering in its abstraction layers, widget system, and cross-platform support.
MQTT-SN Tools is a suite of four command-line applications for working with the MQTT-SN (MQTT for Sensor Networks) protocol. The system provides mqtt-sn-pub for publishing messages, mqtt-sn-sub for subscribing to topics, mqtt-sn-dump for monitoring packets, and mqtt-sn-serial-bridge for serial-to-UDP bridging. All tools share a common C library (mqtt-sn.c/h) that implements the MQTT-SN protocol handling, including socket management, packet encoding/decoding, keep-alive mechanics, and topic mapping. The architecture is modular with clear separation between the protocol library and application-specific logic. Each tool follows a standard pattern: parse command-line arguments, establish UDP connection to an MQTT-SN broker, perform protocol operations (connect, publish/subscribe, etc.), handle incoming/outgoing packets, and clean up resources. The project has active maintenance with recent commits and a test suite.
jsf is a Python library that generates fake data conforming to JSON schemas. It provides programmatic and CLI interfaces for creating realistic test data, supports custom data providers, maintains state for dependent data generation, validates output against schemas, and integrates with FastAPI for automatic API documentation. The architecture follows a modular design where each JSON schema type is handled by a specific class in jsf/schema_types/, with the core parsing logic in jsf/parser.py. The project uses Pants for building, has comprehensive test coverage, and maintains active CI/CD pipelines with automated releases based on conventional commits.
This repository provides a tool for repackaging official Zig programming language releases as Python binary wheels. The core functionality resides in make_wheels.py, which downloads Zig tarballs, verifies their integrity, extracts contents, and rebuilds them as installable Python wheels with appropriate metadata and entry points. The architecture is straightforward: a command-line Python script supported by a GitHub Actions workflow for automated building and deployment. The tool enables Python developers to easily install and use the Zig toolchain (including the zig cc compiler) as a dependency via pip. Key features include reproducible builds (bit-for-bit identical outputs regardless of build environment), support for multiple platforms (Windows, macOS, Linux variants), and automated publishing to PyPI with provenance attestations.
This repository contains educational materials for learning Docker, specifically designed to prepare for the Docker Certified Associate (DCA) certification. It consists of markdown-formatted chapters covering Docker fundamentals, images, volumes, networking, docker-compose, swarm, monitoring, tools, Kubernetes, and enterprise topics. The repository also includes a lab environment setup using Vagrant to provide hands-on experience with Docker in a multi-node cluster configuration. The primary value of this repository lies in its comprehensive documentation rather than executable code. It serves as a structured learning resource that explains Docker concepts with practical examples and setup instructions. The lab directory contains reusable infrastructure-as-code components for provisioning a Docker swarm cluster using Vagrant and VirtualBox, enabling users to create a consistent learning environment.
Eslint Watch is a command-line tool that wraps ESLint to add file watching capabilities. It provides a CLI interface that forwards most options to ESLint while adding its own options like --watch, --changed, and --clear. The architecture is modular, with separate modules for option parsing, command handling, ESLint interaction, and file watching. The tool uses chokidar for file system events and keypress for keyboard input to trigger manual re-lints. It demonstrates solid engineering practices with a clear separation of concerns and a reusable option merging pattern.
docker-copyedit is a CLI tool for editing Docker image metadata, including removing/adding volumes, ports, environment variables, labels, and modifying image configuration like user, workdir, entrypoint, and cmd. The tool works by saving a Docker image to a tarball, extracting and modifying the metadata JSON files (manifest.json and config files), then re-packaging and loading the modified image. It supports both Docker and Podman via command-line flags. The architecture is a monolithic Python application with a clear separation between the CLI wrapper and core implementation. Key functions include parsing Docker image names, executing shell commands with proper error handling, and a custom command-line DSL for specifying image modifications.
This is an Android application: a specialized game browser for Kantai Collection (KanColle), a Japanese HTML5 browser game. It wraps the game client in a custom WebView with SQLite-backed resource caching (images, audio, fonts with HTTP cache-header awareness), a JavaScript bridge (KcsInterface) for XHR interception and canvas screenshot capture, and a side panel for game controls (refresh, mute, screenshot, rotation lock, subtitles, logout). It integrates third-party mods (60 FPS unlock, critical-hit effects, 3D models, language patches) by regex-patching the game's main.js at load time, and supports picture-in-picture, multi-window, gesture controls, and IP-block bypass via proxy override. Architecturally it is a standard Android app: three Activities (EntranceActivity for connector selection, BrowserActivity for the game, SettingsActivity for preferences), a WebViewManager that configures the browser, a ResourceProcess that intercepts and caches all game resource requests, and a KcaContentProvider that broadcasts game API data to companion apps like Kcanotify. The subtitle system uses a clean strategy pattern (SubtitleProvider interface with kc3-translations GitHub and kcwiki API implementations) to display translated voice lines. External dependencies include DMM game servers, OOI proxy connectors, GitHub (version checks, subtitle data, mod sources), kcwiki, and Firebase Crashlytics. The app is actively maintained (last commit 2026-09-11) and well-localized (8 languages), but it carries inherent fragility: the regex-based patchers break whenever the game updates main.js, and the app depends on external services (GitHub, kcwiki, bypass endpoints) that may change or rate-limit. There are no automated tests, and the resource caching logic in ResourceProcess is complex and error-prone. Legacy jniLibs for dead architectures (mips, armeabi) remain in the tree. Despite the niche domain, a few components are genuinely reusable: WebViewL (a WebView that keeps rendering when invisible), VersionDatabase (a generic SQLite key-value store with version tracking), and the SubtitleProvider abstraction (a clean multi-source data fetching pattern). The patcher classes demonstrate a modular, independently toggleable patching design, though they are game-specific.
Haaukins is a cybersecurity training and Capture The Flag (CTF) platform developed at Aalborg University. It orchestrates isolated lab environments for teams, combining Docker containers and VirtualBox VMs to deliver challenges. The system is built as a set of gRPC microservices: a central daemon manages event lifecycle, team assignments, and challenge verification; a store service provides persistence; and an exercise service defines challenge configurations. Participants access labs via a web frontend (Amigo) using browser-based RDP (Guacamole) or WireGuard VPN. The daemon also handles DNS/DHCP per lab subnet, real-time scoreboards via WebSocket, and keylogging for monitoring. The CLI client (hkn) allows administrators to manage events, teams, and exercises. The architecture is modular with clean interfaces for virtualization (Docker/VirtualBox) and storage (in-memory with hooks or gRPC backend), though some components show tight coupling and aging dependencies.
espeak-ruby is a Ruby gem providing a simple API to generate Text-to-Speech audio using the `espeak` command-line tool and optionally compress to MP3 using `lame`. It exposes two main classes: `ESpeak::Speech` for generating speech (speak, save to file, or retrieve raw bytes) and `ESpeak::Voice` for listing available voices. The architecture is a thin wrapper around external CLI commands using `IO.popen`, with a clean hash-based options interface for pitch, speed, voice, amplitude, and capital letter emphasis. The repository also includes a full demo web application (Roda + Stimulus + WaveSurfer) that demonstrates the library in a browser, with a Kubernetes deployment configuration. The core library is well-structured, tested, and actively maintained, but it is a straightforward wrapper with no complex internal logic.