Dynamax is a JAX-native library for probabilistic state space models (SSMs), providing inference (filtering, smoothing, posterior sampling) and learning (EM, SGD, blocked Gibbs) for hidden Markov models (HMMs), linear Gaussian SSMs (LGSSMs), nonlinear Gaussian SSMs (NLGSSMs), generalized Gaussian SSMs (GGSSMs), and switching linear dynamical systems (SLDS). The architecture separates low-level pure functions (e.g., `hmm_filter`, `lgssm_filter`) from high-level object-oriented model classes (e.g., `GaussianHMM`, `LinearGaussianSSM`), all built on JAX for automatic differentiation, vectorization, and GPU/TPU acceleration. The library includes advanced algorithms such as parallel associative-scan filtering/smoothing, information-form Kalman filters, Rao-Blackwellized particle filters, and conditional-moments Gaussian filters (EKF, UKF, GHKF). It is designed for research use, with a focus on numerical correctness and performance, and is accompanied by extensive documentation, tutorials, and a JOSS publication.
Jovian-NixOS is a NixOS overlay and module collection that enables running NixOS on the Steam Deck and similar handheld gaming devices. It provides hardware-specific kernel configurations, firmware update integration, Steam Deck UI (Gaming Mode) support, audio/display driver patches, and a suite of system services (power management, input handling, performance control) modeled after SteamOS. The repository is structured as a Nix flake with a clear separation of concerns: NixOS modules under `modules/` define configuration options for Steam Deck hardware, Steam client integration, and SteamOS-like system settings; a Nix overlay under `pkgs/` provides patched or vendored packages (gamescope, mesa, linux kernel, pipewire, etc.) that are not yet in upstream Nixpkgs or require Steam Deck-specific modifications. The codebase demonstrates strong NixOS engineering practices: modular design, extensive use of lib.mkIf/mkMerge for conditional configuration, hardcoded path patching via replaceVars, and resholve for shell script safety. The documentation system is a custom Ruby pipeline that generates a static site from markdown with options and package listings. While the repository is tightly coupled to NixOS and the Steam Deck domain, it is a well-maintained, production-quality example of how to extend NixOS for specialized hardware.
This repository is a GNU Radio out-of-the-module (OOT) implementation of the LoRa physical layer. It provides a comprehensive set of signal processing blocks for transmitting and receiving LoRa signals, including channel coding (Hamming), interleaving, whitening, CRC, header processing, modulation, demodulation, and frame synchronization. The module is designed for use with GNU Radio 3.10+ and includes hierarchical blocks for quick assembly of transmitter and receiver flowgraphs in GNU Radio Companion or Python. It also features a simulation framework for performance evaluation (BER/FER vs SNR) and has been validated with USRP hardware and commercial LoRa transceivers. The code is modular, well-documented, and actively maintained, with recent updates adding support for lower spreading factors (SF 5-6) and improved soft-decision decoding.
This repository provides a Docker image for running a Palworld dedicated game server. It automates the full lifecycle: installation and updates via SteamCMD, configuration through environment variables (mapped to PalWorldSettings.ini and Engine.ini via envsubst), scheduled backups with retention policy, automatic restarts with player-aware grace periods, player join/leave detection via the Palworld REST API, and Discord-compatible webhook notifications for all major events. The container runs the game server as a non-root user (steam) and includes a CLI tool (restapicli) for administrative commands like announce, kick, ban, save, and shutdown. The architecture is a monolithic Docker container with multiple supervised background processes: the game server itself, a player detection loop, a cron scheduler (supercronic) for backups and restarts, and a game events log maintenance thread. All management scripts are written in Bash with a modular include structure, shellcheck compliance, and color-coded logging. The image also supports an optional companion sidecar container for a web operation panel and Discord status card. The codebase demonstrates solid shell scripting practices: error handling with set -e, function decomposition, environment variable validation, and concurrent-safe logging. While the components are tightly coupled to the Palworld game server domain, several utility modules (colored logging, process supervisor) are self-contained and could be extracted for reuse in other Docker-based projects.
Rutie is a Rust library that provides comprehensive bindings to the Ruby C API, enabling bidirectional integration between Rust and Ruby. It allows Rust programs to embed the Ruby VM, create and manipulate Ruby objects, define Ruby classes and modules from Rust, and wrap Rust structs as Ruby objects with garbage collection support. The architecture is layered: `rubysys` contains raw FFI declarations to Ruby's C functions, `binding` provides safe wrappers around those FFI calls, and `class` offers a high-level public API with well-documented types like `Array`, `Hash`, `RString`, `Class`, and `VM`. The library also includes powerful macros (`class!`, `methods!`, `wrappable_struct!`) that simplify defining Ruby-compatible types and methods. It is actively maintained, supports Ruby 2.7 through 3.4, and uses the `rb-sys` crate for modern Ruby compatibility. The codebase is well-structured, extensively documented with examples, and demonstrates advanced FFI patterns, though it acknowledges that some operations are unsafe due to Ruby's exception handling model.
Goose is a Rust-based load testing framework inspired by Locust, designed for simulating realistic HTTP(S) user behavior against web applications. It provides a programmatic API where users define scenarios and transactions (HTTP requests) with weighted scheduling, then execute them with configurable user counts, ramp-up profiles, and test plans. The framework collects detailed per-request metrics (response times, status codes, errors) and generates comprehensive reports in HTML, JSON, Markdown, and PDF formats. It also includes a live web dashboard for real-time monitoring and control, telnet/WebSocket controllers for runtime command, and coordinated omission mitigation to correct measurement bias in latency statistics. The architecture is channel-based (using flume) with Tokio async runtime, separating user threads, metrics processing, logging, and control surfaces. It is a library that compiles into the user's binary, offering both CLI and programmatic configuration.
Strelka is a real-time, container-based file scanning system designed for threat hunting, detection, and incident response. It ingests files via gRPC clients (Go oneshot, fileshot, filestream) and orchestrates distributed analysis using a Go frontend, Redis coordinator, and a Python backend running 40+ modular scanners. The system extracts metadata, embedded objects, indicators of compromise (IOCs), and performs recursive extraction on archives, documents, emails, and executables. It integrates with YARA, TLSH, ClamAV, OCR, exiftool, Zeek, Suricata, and external sandboxes. Results are streamed back to clients and can be forwarded to Kafka with S3 redundancy. The architecture follows a microservices pattern with optional Envoy proxying and Kubernetes deployment manifests.
OpenDoor is an advanced CLI security reconnaissance platform for directory discovery, subdomain enumeration, WAF detection, and content fingerprinting. It employs a modular architecture with a plugin-based analysis pipeline (sniffers), network transport abstraction (direct, proxy, VPN), and extensive output formatting (JSON, CSV, SQLite, SARIF). Its core scanning engine, state machine, and plugin systems demonstrate sophisticated engineering, featuring auto-calibration, semantic soft-404 diffing, and a clean exception hierarchy.
Lux is a Lua package manager and developer toolchain implemented as a Rust workspace. It is a true application, not a data/research project. The primary entry point is the `lx` CLI (`lux-cli/src/bin/lx.rs`), which dispatches roughly 40 subcommands covering dependency management, installation, building, testing, linting, formatting, vendoring, publishing, and project scaffolding. Underneath, `lux-lib` provides the core engine: rockspec parsing/execution, dependency resolution, lockfile management, source fetching with integrity verification, multi-backend builds, install-tree management, Lua version detection, and LuaRocks-compatible packaging. The workspace also includes `lux-lua` (a Lua API library), `lux-lsp` (progress reporting for language servers), `lux-macros` (proc macros for Lua serialization), and Nix packaging helpers. The primary data flow begins with `lux.toml` project files and workspace manifests. The dependency resolver (`lux-lib/src/pipeline/resolve.rs`) uses a package database chain and concurrent discovery to produce a package graph, which is materialized into a `lux.lock` lockfile with SRI hashes, version constraints, source URLs, and entrypoints. Packages are downloaded from LuaRocks-compatible servers, git remotes, or vendored directories, then built through backends for builtin, make, cmake, rust-mlua, rust-binary, and tree-sitter parsers. Final artifacts are installed into versioned rock trees or flat dist trees, and a Lua loader (`lux-lua/src/loader.rs`) makes those packages requireable from Lua. External dependencies include LuaRocks.org servers, git, C/CMake toolchains, optional Lua installations, and an optional external manifest cache service. Lux is actively maintained and shows strong engineering practices: consistent builder-pattern APIs, typed diagnostics, well-structured error enums, extensive integration tests, cross-platform CI, and a sophisticated Nix overlay. However, it is still pre-1.0 and evolving quickly, with many breaking changes in recent releases. Known weaknesses include non-transactional install operations, hardcoded Lua version hashes, several unsafe code paths, a very large `lua_impls.rs` file, and some disabled CI matrix entries for Lua 5.5 and LuaJIT. Overall, this is a mature and feature-complete package manager with genuinely reusable low-level components.
This is a personal dotfiles repository for a Linux development environment, managed declaratively with Nix (NixOS + Home Manager) and mise. It configures the entire user experience: shell (zsh, nushell), editor (Neovim with hundreds of plugins), terminal (WezTerm, Alacritty), window managers (Hyprland, Sway, i3), desktop widgets (Waybar, EWW, Conky), AI coding assistants (Claude Code, Codex), and a sophisticated security sandbox (firejail + tinyproxy) for network-isolated Neovim sessions. The repository is not a standalone application but a comprehensive, modular configuration system that turns a Linux machine into a highly optimized development workstation. Architecturally, the repo is organized around a Nix flake that defines system-level (NixOS) and user-level (Home Manager) configurations, with mise handling per-user tool versioning and dotfile symlinks. Configuration files are split into modular directories (e.g., `config.d/` for i3, sway, tmux; `lua/rc/pluginconfig/` for each Neovim plugin). The Neovim configuration alone contains over 150 plugin-specific setup files, each following a consistent pattern of calling `setup()` with keymaps. The zsh configuration uses a similar modular approach with `rc/pluginconfig/` and `rc/myplugins/` directories. Notable patterns include: mise tasks with pinned tool headers for CI efficiency; pmy fuzzy-finder rules with separate options/subcommands text files for reusable CLI completions; Nushell autoload scripts that clone modules from GitHub with null fallback and state caching; and a comprehensive firejail profile for sandboxing Neovim with multiple network modes. The repository also includes CI workflows for linting, installation testing, and benchmarking shell/Neovim startup times. While the repo is actively maintained and well-structured, it is inherently personal—many configurations assume the author's hardware, preferences, and workflow. There is some legacy commented-out code and overlapping tool configurations (e.g., multiple window managers, multiple bar systems). However, the modular patterns and isolated components (pmy rules, Nushell autoload, zsh plugins, Neovim plugin configs) are reusable in other dotfiles or development environment projects.
rclip is a command-line semantic photo search tool that indexes local image collections using a CLIP model (OpenCLIP ViT-B/32-256) and supports natural-language, image-to-image, and combined queries with boolean operations. The core architecture is monolithic: a Python package with modules for model inference (ONNX/CoreML), SQLite-based feature caching, image preprocessing, and a Textual terminal user interface for interactive browsing. It is fully offline and privacy-preserving, supporting a wide range of image formats including HEIC, raw (CR2, DNG, ARW), and standard web formats. The tool is distributed via PyPI, Snap, AppImage, Homebrew, and Windows MSI, with careful compliance management for third-party licenses, codecs, and model artifacts. It includes an extensive test suite (unit and end-to-end), CI/CD via GitHub Actions, and a compliance toolkit that enforces license policies during builds. The codebase is well-structured and demonstrates good engineering practices, though it relies on a pinned version of textual-image that uses a private API, introducing some technical drift risk.
This is the official Moodle mobile app, a large hybrid application built with Angular 20, Ionic 8, and Cordova 13. It is a client for the Moodle LMS and talks to Moodle sites through Moodle web services. The application uses an offline-first architecture with per-site SQLite schemas, sync/cron services, prefetch handlers, and a file pool, allowing users to browse courses, participate in activities (assignments, quizzes, forums, SCORM, H5P, etc.), receive push notifications, and manage files while disconnected. The primary entry points are `src/main.ts`, the Angular root component `src/app/app.component.ts`, and lazy-loaded modules under `src/core/features/` and `src/addons/`. The app includes a custom Cordova plugin for secure storage, diagnostics, and install referrer tracking, plus a Behat plugin for acceptance testing. Although the repo is dominated by application code, it contains some data-adjacent artifacts: offline database schemas, xAPI statement support, and language-pack generation scripts; these are not research pipelines and are best understood as application infrastructure.
This repository is primarily an 'awesome list' curating fuzzing (fuzz testing) resources - books, talks, papers, tools - organized by venue and type. The core content lives in a single README.md file. What distinguishes it from a simple list is a set of well-engineered Python scripts (ndss.py, sp.py, usenix.py) that automatically scrape conference accepted-paper pages (NDSS, IEEE S&P, USENIX Security) and match titles containing 'fuzz'. For IEEE S&P, the sp.py script goes further by verifying bibliographic metadata via the Crossref API before proposing entries, ensuring only validated DOIs are suggested. These scripts are triggered manually via GitHub Actions workflows, generating pull requests rather than writing directly. The code exhibits careful HTML parsing with validation, idempotent update logic, comprehensive error handling, and extensive unit tests. While the repository's primary output is a static list, the supporting automation demonstrates production-quality data collection and proposal pipelines that could be reused for maintaining other curated lists.
onnx2tf is a production-grade Python CLI and library that converts ONNX models into multiple deployment formats: LiteRT/TFLite flatbuffer (the current default path), SavedModel, Keras H5, TF1 .pb, and PyTorch artifacts (nn.Module package, TorchScript, state_dict, Exported Program, Dynamo ONNX). It also performs direct LiteRT-to-PyTorch conversion. The conversion pipeline supports INT8 dynamic/static quantization, dynamic input shapes, non-max suppression optimization, and per-op accuracy validation against ONNX Runtime; users can override individual operator attributes via JSON parameter-replacement files, and the repo ships benchmark scripts for TFLite and SavedModel latency. The architecture is compiler-style. The newer flatbuffer_direct backend lowers ONNX into a custom three-layer IR (ModelIR/OperatorIR/TensorIR), runs hundreds of layout, shape, quantization, and architecture-specific orchestration passes (NHWC/NCHW transpose elimination, attention/QKV recovery, quantized-reshape folding, SiNet/SPP/recurrent patterns), then serializes directly to TFLite flatbuffer via a generated schema binder, bypassing SavedModel. A legacy tf_converter backend (onnx2tf/ops/*.py) still builds TensorFlow graphs per ONNX op using shared transpose/replacement decorators. Pass execution is managed by an OrderedPassManager with transactional rollback, fingerprints, and cycle detection, backed by a producer/consumer graph index and layout-state validation. Testing is extensive (~200 files) but unusually brittle: a large fraction of tests parse the AST of lower_from_onnx2tf.py to assert exact call order, phase IDs, and statement structure, so refactors break tests without behavior changes. The pass suite has proliferated into dozens of architecture-specific orchestrations, and the two backends duplicate op semantics. Despite this, the core IR and pass-management layers are well-engineered, dependencies are pinned (uv.lock), CI/Docker are present, and the project is actively maintained with a rapid release cadence.
django-baton is a Django application that transforms the built-in admin interface with a modern, customizable UI. It provides a configurable menu, button themes, form tabs, custom list filters, changelist includes, integrated AI features (translation, summarization, correction, image alt-text and subject location), and an autodiscover admin site. The architecture is a Django reusable app with a Python backend (views, models, filters, templates, and template tags) and a frontend built with Webpack, SCSS, and JavaScript that overlays the admin HTML via signals and template overrides. Key entry points are the `BatonAdminSite` (which auto-registers all models) and the JSON endpoints for menu and AI operations (e.g., `/baton/ai/translate/`). External dependencies include Django, requests (for AI API calls to `baton.sqrt64.it`), and optional rich-text editor integrations. The codebase demonstrates solid craftsmanship with reusable patterns like custom admin filters, a pluggable AI editor adapter, and a config-driven theme system, but some parts are tightly coupled to Baton's global configuration.
Nextcloud News is an RSS/Atom feed reader app for Nextcloud. It provides a PHP backend (MVC with controllers, services, DB mappers) and a Vue 3 + TypeScript frontend. Users can subscribe to feeds, organize them into folders, read articles with read/unread/starred states, apply keyword filters, import/export OPML, and sync with mobile/desktop clients via REST APIs. Background cron jobs handle feed updates and cleanup. The architecture follows Nextcloud's app framework with scoped dependencies to avoid conflicts. Key entry points include the web UI (Vue SPA), CLI commands (`occ news:*`), and API endpoints (v1-2, v1-3, v2). External dependencies include feed-io for parsing, Guzzle/PSR-18 for HTTP, and Readability.php for full-text extraction. The codebase is well-tested with unit, integration, and BATS tests, and uses modern tooling (Vite, PHP 8.2+).
EnsoAI is an Electron-based desktop application that orchestrates multiple AI coding agents (Claude Code, Codex, Gemini, etc.) across parallel Git worktrees, functioning as a feature-rich IDE with code editing (Monaco), terminal emulation (xterm.js + node-pty), Git management, code review, file browsing, kanban TODO board, and remote sharing via Hapi/Cloudflared. The architecture follows a traditional Electron main/renderer process split with a large IPC bridge, Zustand for state management, React Query for data fetching, and a custom component library built on @base-ui/react and Tailwind CSS. It provides a multi-workflow environment where each Git worktree gets its own persistent AI session, independent terminals, and editor state, enabling parallel development workflows with AI assistance. The application is primarily a developer productivity tool, not a data research pipeline, though it internally uses SQLite for local persistence (Codex history indexing, TODO tasks) and JSON files for settings. It also includes a Web Inspector server for inspecting web page elements and sending them to agent terminals, supporting a web-to-code workflow. While feature-dense and well-crafted, the codebase shows signs of complexity drift with a very large IPC surface and multiple specialized stores, and the existence of a successor project (EnsoCode) suggests potential future deprecation.
py2exe is a specialized build tool and library designed to freeze Python scripts into standalone Windows executables (.exe). It supports console applications, GUI applications, and Windows services. The architecture consists of a Python package (py2exe) that analyzes dependencies and bundles code, combined with C-based runtime stubs (MemoryModule, run.exe, etc.) that embed the Python interpreter and execute the frozen script from memory or disk. The primary entry point is the `py2exe.freeze()` API, which replaces the deprecated `distutils`/`setup.py` interface. It relies heavily on `pefile` for binary analysis and `setuptools` for packaging. The tool is actively maintained, supporting Python versions 3.10 through 3.14. It features a robust hook system for handling complex third-party packages like NumPy, SciPy, and Matplotlib. The codebase demonstrates high craftsmanship in its C integration for memory-based DLL loading and dependency scanning, making it a critical tool for distributing Python applications on Windows without requiring a Python installation.
This repository provides the official documentation, OpenAPI specification, and client libraries for the Congress.gov API (v3), a public REST API that exposes U.S. federal legislative data including bills, amendments, members, committees, hearings, nominations, treaties, and Congressional Record content. The repo is primarily a supporting asset for the API, containing detailed endpoint documentation in Markdown, a machine-readable OpenAPI spec (openapi.yaml/json), and example client implementations in Java and Python. The Python client (cdg_client.py) demonstrates a reusable pattern with dynamic HTTP method dispatch, session management, and optional keyring-based API key storage. The Java client (CDGClient.java) uses java.net.http.HttpClient and a config file reader. The repository does not contain the actual API server implementation; it is a companion repository for developers integrating with the Congress.gov API. The codebase is well-structured, actively maintained (as evidenced by the changelog), and the documentation is comprehensive, though some minor typos exist. The duplicate client directories (java/ and api_client/java/, python/ and api_client/python/) suggest some organizational drift, but the core components are solid.
This repository provides a comprehensive suite of GitHub Actions for Terraform and OpenTofu infrastructure-as-code workflows. It covers the full lifecycle: planning, applying, validating, formatting, testing, output retrieval, remote state management, workspace management, and drift detection. Each action is available in both `terraform-*` and `tofu-*` variants, sharing a common Docker image and Python backend. The architecture is a collection of Docker-based composite actions that wrap Terraform/OpenTofu CLI commands, with a sophisticated Python layer for version resolution, PR comment management, plan comparison, and backend fingerprinting. Key entry points are the shell scripts in `image/entrypoints/` and the Python modules under `image/src/`. External dependencies include the Terraform and OpenTofu binaries, GitHub API, Terraform Cloud API, and various state backends (S3, Azure, GCS, etc.). The codebase demonstrates high craftsmanship in areas like version constraint parsing, plan normalization, and PR comment hashing, but carries some technical debt from supporting legacy Terraform versions and dual-tool maintenance.