Parsons is a Python library providing a unified interface to dozens of third-party services commonly used in progressive political campaigns and advocacy organizations. It acts as an ETL/integration toolkit, with a core `Table` abstraction (backed by petl) that normalizes data from APIs, databases, and file formats. The library includes connectors for voter file platforms (NGP VAN, PDI, TargetSmart, Catalist), fundraising (ActBlue, Donorbox, Braintree), communication (Twilio, Slack, Gmail), event management (MobilizeAmerica, ActionNetwork), and cloud storage (S3, GCS, Azure). It also provides database connectors (Postgres, Redshift, BigQuery, MySQL, SQLite) and utilities for dbt integration, credential management, and file handling. The architecture is a monolith of loosely coupled connector modules, each following a consistent pattern of credential resolution via environment variables and returning `Table` objects. The codebase is well-tested with unit tests (mocked) and some integration tests, but many connectors rely on external APIs that may drift. The library is actively maintained by The Movement Cooperative, with recent commits and CI/CD pipelines.
This repository contains a proof-of-concept exploit for CVE-2023-3269 (StackRot), a use-after-free vulnerability in the Linux kernel's maple tree implementation for managing virtual memory areas (VMAs). The exploit demonstrates privilege escalation from an unprivileged local user to root, and also container escape, targeting kernel version 6.1.25. It is verified to work in the Google kCTF VRP environment and is built and tested via GitHub CI using QEMU. The exploit is structured into three main components: node_master (orchestrator), node_free (triggers the UAF), and node_use (reads /proc/self/maps to leak addresses and control execution). It uses a deep directory tree to prolong VMA iteration, allowing the RCU grace period to expire and convert a use-after-free-by-RCU into a genuine use-after-free. Then it employs slab feng shui to gain control of freed maple nodes, leaks kernel addresses via /proc/self/maps, and executes a ROP chain to gain root privileges and escape containers. The code is well-crafted with a custom minimal libc (nolibc) and inline assembly for syscalls. The syscall wrappers and clone helper are cleanly implemented and could be reused in other kernel exploit projects. The repository includes a Makefile, CI configuration, and environment files (kernel image, initramfs) for easy reproduction.
This repository is a PowerShell-based desktop GUI application for managing Microsoft Intune (Endpoint Manager) configurations. It uses the Microsoft Graph API and Azure Management APIs to perform operations such as exporting, importing, comparing, and bulk copying Intune objects (policies, profiles, apps). The application features a WPF user interface defined in XAML, MSAL-based authentication with proxy support, and a modular extension system that allows adding new functionality (e.g., documentation generation in HTML, Markdown, JSON, Word, CSV). It also includes tools for ADMX policy ingestion, Intune app upload (MSI, MSIX, iOS, Android, Win32), and encryption key extraction from .intunewin files. The codebase is primarily PowerShell with some C# helper classes for MSAL integration.
This is a Go application that runs an SSH server at jobs.hackclub.com, presenting Hack Club's open job positions as a virtual filesystem. Users connect via SSH and interact with a terminal-based shell supporting commands like `ls`, `cat`, `help`, and `exit`. Job listings are fetched from Polymer's hire API, converted from HTML to Markdown, and rendered in the terminal with support for light/dark themes, autocomplete, paging, and an animated intro sequence. The project is a playful developer-facing tool rather than a traditional web app or data pipeline.
pylinac is a Python library for performing TG-142 QA tasks on linear accelerators. It provides high-level analysis modules for common radiotherapy QA tests—VMAT, Winston-Lutz, PIPS, field analysis, planar imaging, log analysis, CT, and star shot—plus lower-level core modules for image handling, gamma analysis, ROI calculations, and structured results. The library is used as a dependency in clinical QA workflows and exposes a consistent API: instantiate an analysis class with a DICOM/log file path, call `.analyze(...)`, then access `.results_data()`, `.publish_pdf()`, or `.plot_analyzed_image()`.
This repository is an 'awesome list' — a static Markdown index of externally hosted Claude Code skills, organized into 14 categories (documents, development, data, science, writing, learning, media, health, collaboration, security, utility, articles, and collections). It contains no source code, no executable skills, no CI/CD, and no tests. The production function is discovery: a human or AI agent reads the README to find third-party skill repositories, then clones or installs those skills separately. Architecture is a single README with external links plus a few embedded sponsor images. There are no data flows or APIs. The list is actively maintained with a recent commit and a large volume of open issues, indicating ongoing community input. The core value is the curation and categorization of 150+ external skills, not software engineering craftsmanship. Sponsored placements appear at the top, so it is not purely community-driven. Overall, a useful and well-organized directory, but with zero in-repo technical content.
phusion/baseimage-docker is a specialized Ubuntu base image optimized for Docker containers. It solves common Docker container problems including the PID 1 zombie reaping issue (via a custom /sbin/my_init process), syslog blackhole problem (using syslog-ng that forwards logs to docker logs), and APT incompatibilities. The image provides service supervision through runit, tools for running processes as different users (setuser), easy SSH access (optional), and environment variable management. It's designed to be used as a base image for Docker applications, offering a minimal but production-ready Ubuntu environment.
This repository implements a multi-agent company research system that generates structured, source-backed briefings. The backend is a FastAPI application that orchestrates a LangGraph workflow: specialized researcher nodes (company, industry, financial, news) use Tavily search and LLM-generated queries to collect data, a curator filters by relevance scores, an enricher fetches raw content, a briefing node synthesizes category summaries, and an editor compiles the final report. The frontend is a React + Vite UI that submits research requests, streams progress via Server-Sent Events (SSE), and displays the completed report with PDF export. The system supports flexible LLM configuration via OpenRouter (recommended) or direct OpenAI/Gemini keys, and optionally persists jobs in MongoDB. The architecture is modular, with clear separation between research, curation, enrichment, briefing, and editing phases, all connected through a state graph. The code demonstrates solid use of async patterns, LangGraph for workflow orchestration, and a clean React frontend with real-time updates.
Repository contains a complete open-source guitar-pedal product line: custom KiCad PCB and enclosure hardware for the Electrosmith Daisy Seed (125B, 1590B, and 1590B-SMD variants) plus the matching bare-metal C++ firmware that runs on the STM32H750. The firmware is the dominant software artifact: a modular, block-based audio effects platform with 40+ loadable DSP modules (drive, delays, reverbs, modulation, granular, spectral, tuner, looper, drum/synth voices, NAM neural amp model, IR cab loader), a menu-driven OLED UI, MIDI CC/note support, footswitch control, and persistent effect presets. The architecture is a compile-time composition rather than a runtime plugin system. A BaseEffectModule interface and EffectChain allow serial effects per hardware variant, selected through loaded_effects.h and Makefile target flags. GuitarPedal.cpp drives the real-time audio callback, control monitoring, MIDI dispatch, and autosave. Hardware variants are abstracted by BaseHardwareModule subclasses that define pin maps, LEDs, true-bypass switching, and display wiring. Heavy DSP state (delay lines, FFT buffers) is placed in SDRAM/DTCM via global DSY_SDRAM_BSS blocks, which gives low latency but severely limits how many effect instances can be active. Overall quality is good for an embedded audio project: the effect-module pattern is consistent, several components (NAM A2 inference, Dattorro reverb, persistent-store layout migration, tape-flutter modulation) are genuinely reusable, and CI builds all variants. The codebase carries real maintenance debt: hardcoded sample-rate assumptions, global-buffer single-instance effects, commented-out experiments, duplicated hardware modules, and patched copies of upstream DSP headers. It is actively maintained but not a polished library; reuse is best done by extracting individual effect or utility headers rather than adopting the project wholesale.
This repository is a community theme for Obsidian, the local-first Markdown note-taking application. It is not a data pipeline or application codebase; it is a CSS distribution artifact: a single theme.css (~28,000 tokens) plus a legacy obsidian.css copy, shipped with an Obsidian manifest.json for the community marketplace. When installed, the theme reskins the entire Obsidian UI — editor, live preview, reading view, sidebar, modal dialogs, mobile interface — to mirror the design language of the Things 3 task manager. The code operates entirely through Obsidian's CSS variable contract (--color-base-*, --text-*, --interactive-*) and its DOM class structure, with no JavaScript, build tooling, or test suite. The maintained theme.css is well-engineered for its medium: a centralized design-token system with light/dark schemes, responsive mobile/tablet breakpoints, print handling, and a declarative @settings YAML block that renders as a user-facing configuration panel via the Style Settings community plugin. Its standout feature is an alternate checkbox system encoding 20+ semantic task states (important, star, question, bookmark, fire, idea, savings, up/down, PR states, etc.) as SVG data-URI masks applied via -webkit-mask-image — a self-contained, genuinely portable CSS pattern. A large icon-replacement block (heavily derived from @kepano's Minimal theme, as credited in the README) swaps Obsidian's default Lucide icons for a custom line-icon set without external network requests. Plugin-specific overrides provide polish for Kanban, Todoist, Checklist, Calendar, and Dataview. Caveats: the repo carries two divergent theme files — obsidian.css is V1 (version 1.8.2, kept for older Obsidian releases) while theme.css is the current V2 — and selectors for both the legacy CodeMirror 5 editor (.cm-s-obsidian, .CodeMirror) and the modern CodeMirror 6 editor (mod-cm6) are maintained side by side. The icon-replacement block is largely inherited rather than original, and the code uses many !important overrides and some commented-out experiments, which is normal for this genre. Within the Obsidian theme ecosystem this is a high-craft, actively maintained project: 1026 stars, 54 open issues, recent commits, and a clean MIT license.
Just a Sample is a modern, open-source audio sampler plugin for VST3 and AU formats, built with the JUCE framework. It provides sample playback with time-stretching and pitch-shifting (via the Bungee library), a reorderable FX chain (reverb, chorus, distortion, EQ), waveform editing, recording, and microtonal tuning support via MTS-ESP. The architecture is a single plugin with a modular internal design: the core audio processing lives in CustomSamplerVoice, while UI components like SampleEditor, SampleNavigator, FxChain, and CustomLookAndFeel are separated into distinct modules. Effects are implemented as independent classes (Reverb, Chorus, Distortion, BandEQ) with a common interface. The project also includes Reaper-specific VST3 extensions for tighter DAW integration. The codebase demonstrates solid engineering practices with custom UI patterns, thread-safe sample loading, and a theme system supporting dark/light modes. While some parts show active development (TODOs, experimental features), the overall structure is clean and well-organized, making it a good reference for JUCE-based plugin development.
This repository is a content-based Claude Code skill package rather than a conventional software service. It contains two agent skills — /tutor-setup and /tutor — that an LLM coding assistant executes using filesystem and WebFetch tools. tutor-setup scans a working directory, auto-detects whether it contains source code or documents, and generates an Obsidian StudyVault: concept notes, dashboards, exam-traps, and practice questions, with strict rules for source traceability, tag registries, wiki-linking, and folder conventions. tutor-setup operates through detailed phase models (D1-D9 for documents, C1-C9 for codebases), and codebase mode produces architecture maps, module notes, API surfaces, and onboarding exercises. tutor then reads that vault and runs interactive 4-question quiz rounds, updating concept-level progress files and a compact dashboard; it supports diagnostic, weak-area drill, section review, and hard-mode sessions, all governed by a zero-hint quiz design rule in references/quiz-rules.md. The implementation is almost entirely Markdown instructions plus two small Bash install/uninstall scripts; there is no compiled code, test suite, CI pipeline, or dependency manifest. The operational logic is prompt/instruction engineering that Claude Code interprets. External dependencies are Claude Code (or a compatible npx-skills-aware assistant), Obsidian for reviewing generated vaults, pdftotext/poppler for PDF extraction, and the assistant's built-in Read, Write, Edit, Glob, Grep, Bash, WebFetch, and AskUserQuestion tools. The data flow is unidirectional: source files in the CWD are scanned and extracted, transformed into StudyVault markdown, then quiz answers update concept files and dashboard aggregate stats. The skill enforces a CWD boundary to avoid accessing files outside the working directory. The strong point is unusually detailed and internally consistent procedural specification: mandatory source-content verification, per-topic coverage rules, tag registries, active-recall fold callouts, interlinking requirements, and self-review quality checklists. Weaknesses are the absence of automated tests/CI and versioned dependency pins, and behavior ultimately depends on the host LLM following prompt rules correctly. The README also references a different GitHub owner (RoundTable02) than the repository path (bevibing/tutor-skills), indicating a fork or repackage whose provenance should be verified before use. Overall, it fulfills its stated purpose well, and several Markdown modules are genuinely reusable as templates for other agent skills, study-vault generators, or adaptive quiz systems.
This repository provides Docker images and deployment configurations for running Thumbor, an open-source photo thumbnail service. It builds three main components: the core Thumbor image service, an nginx-based caching proxy (nginx-proxy-cache), and a remote computer vision service (remotecv) for asynchronous smart cropping and feature detection. The project includes build scripts, CI/CD workflows, testing infrastructure, benchmarking tools, and deployment recipes (docker-compose and Kubernetes) to facilitate easy deployment and scaling of Thumbor-based image processing systems. The architecture follows a microservices pattern where Thumbor handles image processing, nginx-proxy-cache provides caching and reverse proxying, and remotecv offloads heavy computer vision tasks.
Podkop is an OpenWrt LuCI application that provides a comprehensive web interface and backend service for managing the sing-box proxy engine on routers. The architecture is a monolith split between a TypeScript frontend compiled to LuCI-compatible JavaScript and a shell-based backend orchestrated by the `/usr/bin/podkop` CLI script. The frontend employs a clean reactive store pattern and modular validators, while the backend handles sing-box configuration generation, nftables TPROXY routing, FakeIP DNS management, and community list updates. The system allows users to configure complex proxy routing rules (VLESS, Trojan, Shadowsocks, etc.), monitor real-time traffic and connections via the Clash API WebSocket, and run extensive diagnostics on DNS, sing-box, nftables, and FakeIP functionality. Data flows from UCI configuration through shell scripts to sing-box JSON configs, and from external community lists (GitHub) into local sing-box rulesets. The project is actively maintained with recent commits, CI pipelines, and responsive issue triage. However, it carries medium technical drift due to tight coupling to the LuCI framework, reliance on external services (`fakeip.podkop.fyi`, `ip.podkop.fyi`), a monolithic shell backend with global state and an empty migration function, and heuristic security masking that may not cover all edge cases. The most reusable components are the frontend validators (`fe-app-podkop/src/validators/`), which provide robust, well-tested parsing for various proxy URLs, and the generic `StoreService` pattern. The shell helper library (`podkop/files/usr/lib/helpers.sh`) also contains reusable URL parsing and validation functions. These components demonstrate high craftsmanship and can be extracted for use in other networking or proxy management projects.
This repository is a React component library for embedding Cloudflare Stream video players. It provides a `<Stream>` component that handles loading the Cloudflare Stream SDK, creates an iframe for the player, and synchronizes React props with the player's imperative API. The architecture centers around custom React hooks for script loading (`useStreamSDK`), property synchronization (`useProperty`), and event management (`useEvent`). The component is designed to be used in React applications, with props controlling video playback, appearance, and event handling. External dependencies include React (peer dependency) and the dynamically loaded Cloudflare Stream SDK.
Zui (formerly Brim) is an Electron-based desktop application for network security monitoring and data exploration. It provides a graphical interface to query and visualize data stored in a Zed/SuperDB lake, with a focus on Zeek and Suricata log analysis. The application supports importing packet captures (pcap), structured logs (Zeek TSV, NDJSON, CSV, Parquet), and offers a rich query editor (Monaco), histogram, table/inspector views, and export workflows. The codebase is a monorepo (Yarn workspaces, Nx) with packages for type definitions (`superdb-types`), a Node.js client (`superdb-node-client`), sample data, and an e2e test framework (`app-player`). The architecture follows a domain-driven pattern with handlers and operations, a Redux store with versioned state migrations, and a plugin system for extensibility. While the application is actively maintained and functionally rich, it exhibits some technical drift due to a mix of legacy and modern patterns, a large migration history, and tight coupling between core and plugins.
Apache ServiceComb Java Chassis is a comprehensive microservices framework for Java, providing service registration/discovery, RPC invocation (over REST, Highway, WebSocket), dynamic load balancing, circuit breaker, retry, rate limiting, and other governance capabilities. It follows a modular, SPI-based architecture with strong OpenAPI/Swagger integration for API contract generation. The framework supports multiple service registry backends (ServiceCenter, Nacos, Consul, etcd, ZooKeeper, local/lightweight) and is primarily used as a library within Spring Boot applications. The repository includes extensive demo modules for various transport, registry, and governance combinations, serving both as integration tests and example code. It is not a data or research project; all data flows are operational (configuration, metrics, tracing).
Trainbot (Onlytrains) is a computer vision application that automatically detects trains passing a fixed camera, stitches the train's frames into a single composite image, and logs sightings to a SQLite database. It is designed to run on a Raspberry Pi with a camera (USB, Pi Cam 3, or video file) and can optionally upload results via FTP to a web server. The project is unmaintained as stated in the README. Architecturally, it is a monolith Go backend with three CLI binaries: `trainbot` (main detection loop), `confighelper` (interactive crop selection), and `cleanup` (orphaned blob removal). The backend captures frames using `pkg/vid` (abstraction over V4L2, libcamera-vid, ffmpeg), processes them through a stitch pipeline that detects motion, computes frame offsets via patch matching, fits a constant-acceleration model using RANSAC, and then blends frames into a single JPEG and an animated GIF. Results are stored in a SQLite database and served by a built-in HTTP server. The frontend is a Vue 3 static SPA that loads the SQLite database client-side to display train sightings, stats, and images with no server-side rendering. Key highlights include highly optimized image processing: the `pkg/pmatch` package offers four implementations of cosine-similarity patch search (slow Go, optimized Go, Cgo, Vulkan compute), and the `pkg/ransac` package provides a generic RANSAC fitter for the speed model. The codebase demonstrates strong engineering craftsmanship with a clear package structure, extensive tests, test data sets, and a CI pipeline. However, heavy reliance on Cgo and Vulkan, plus the explicit unmaintained status, introduce cross-compilation complexity and potential drift from modern tooling.
This repository is a Godot 4 addon that integrates the libsm64 library (a reimplementation of Super Mario 64's game engine) into Godot via GDExtension. It provides both a low-level C++ API exposed as a Godot singleton (`LibSM64`) and high-level GDScript nodes (`LibSM64Mario`, `LibSM64StaticSurfaceHandler`, `LibSM64SurfaceObjectsHandler`, `LibSM64AudioStreamPlayer`) for easily adding Mario characters and surface geometry to Godot scenes. The addon handles coordinate system conversion (SM64 to Godot), fixed-rate physics ticking at 30 FPS with interpolation for smooth rendering, and dynamic material switching based on Mario's power-up state. A demo project with multiple playable scenarios (Bob-omb Battlefield, many Marios, flying range) is included, along with a ROM picker dialog for loading the required Super Mario 64 US ROM. The architecture is a classic Godot plugin: a GDExtension shared library (built from C++ source in `extension/`) registers new engine classes and a singleton, while GDScript files in `addons/libsm64_godot/` provide editor integration and higher-level abstractions. The core C++ code wraps all libsm64 functions (global init, Mario creation/tick, surface loading, audio) and exposes them as Godot methods. The GDScript layer adds node lifecycle management, input mapping, interpolation, and surface handling utilities. The demo project in `libsm64_godot_demo/` showcases the addon with custom scenes, a camera rig, HUD, and input configuration. Key external dependencies are the libsm64 C library (included as a Git submodule) and the godot-cpp bindings (also a submodule). The addon requires a specific Super Mario 64 US ROM (SHA-256 verified) to function, as libsm64 uses original game assets. The build system uses SCons and GitHub Actions to compile the GDExtension for Windows, macOS, Linux, and Web platforms. The code is well-structured with clear separation between C++ engine bindings and GDScript gameplay logic, making it a solid reference for integrating complex C libraries into Godot.
Fazen2d is a C++ library for creating 2D graphics and handling input in the Windows console. It provides geometric primitives (points, lines, boxes, circles, text), a rendering system with double buffering to prevent flicker, input handlers for keyboard and mouse, and utility classes for timing and color management. The architecture is modular, with clear separation between rendering, geometry, input, and state management. The main entry point is in main.cpp, which demonstrates a simple animation loop. The library relies solely on the Windows API and C++ standard library.