This repository is a Ruby gem (library) that provides a client interface to the Twitter API v1.1, covering both REST and Streaming endpoints. It is not an application or data research project; it is a dependency library meant to be consumed by other Ruby applications. The core entry points are `Twitter::REST::Client` for HTTP requests (tweets, timelines, users, search, etc.) and `Twitter::Streaming::Client` for real-time streaming connections. The library models API responses as typed objects (e.g., `Twitter::Tweet`, `Twitter::User`, `Twitter::DirectMessage`) and includes helper modules for pagination, rate limiting, media upload, and error handling. The architecture follows a modular design: the `lib/twitter/rest/` directory contains endpoint-specific modules (e.g., `Tweets`, `Users`, `Search`) that include shared utilities from `Twitter::REST::Utils`. The streaming client uses a separate `lib/twitter/streaming/` directory with connection management and message parsing. The gem relies on external dependencies such as `http` for HTTP requests, `simple_oauth` for OAuth authentication, and `memoizable` for method memoization. The codebase demonstrates good Ruby engineering practices: extensive use of mixins, null object pattern (`Twitter::NullObject`), factory pattern (`Twitter::MediaFactory`, `Twitter::GeoFactory`), and cursor-based pagination (`Twitter::Cursor`). Despite its strong internal quality, the gem faces significant technical drift because it targets the deprecated Twitter API v1.1. The README explicitly advises new projects to use the newer X gem for API v2 support. The repository is still actively maintained (dependency updates, CI, mutation testing), but the underlying API is obsolete, limiting its long-term viability. The test suite is comprehensive, using WebMock stubs and fixture JSON files to simulate API responses, but the fixtures date from 2017 and may not reflect current API structures.
FastRTC is a Python library that enables developers to build real-time audio/video streaming applications with minimal code. It provides a high-level `Stream` class that integrates with Gradio for automatic UI generation and supports both WebRTC and WebSocket protocols. The library includes built-in handlers for voice activity detection (VAD) via Silero, speech-to-text via Moonshine, text-to-speech via Kokoro/Cartesia, and turn-taking logic. It also offers TURN credential helpers for Cloudflare, Twilio, and Hugging Face. The architecture revolves around defining a handler function that processes media chunks, wrapping it with turn-taking decorators, and creating a Stream object that handles signaling, connection management, and UI rendering. The codebase is actively maintained with frequent commits and an extensive set of demos integrating with various LLMs and AI services.
Wisp is a local-first, real-time meeting transcription desktop application built with Rust and SvelteKit, using Tauri v2 for cross-platform deployment (macOS Apple Silicon, Windows x64). It captures microphone and system audio, runs on-device automatic speech recognition (ASR) using multiple engines (whisper.cpp, sherpa-onnx, Apple Speech), provides live speaker-diarized transcripts with timestamps, and supports offline semantic search via local ONNX embedding models. The architecture is modular, with pluggable traits for audio sources, ASR engines, denoisers, echo cancellers, and model stores. It also offers optional cloud transcription (OpenAI, Gemini, Groq, etc.) and AI assist features. Although primarily an application, it integrates significant data engineering patterns for streaming audio processing, feature extraction (VAD, diarization), and on-device model management.
monkeSearch is a macOS-native file search tool that uses a local LLM to parse natural language queries into structured search parameters, then executes Spotlight searches via PyObjC. The system breaks queries into file type indicators (with specificity detection), temporal expressions, and residual keywords, converting them to NSPredicates using UTIs for file type matching and date comparisons for temporal filtering. It features a clean separation between LLM-based query parsing (query_gen.py) and Spotlight execution (parser.py), with the former being particularly well-engineered for reuse. The tool is designed for offline, agentic use with no cloud dependencies, targeting low-resource environments.
This is a Preact single-page application that provides a user interface for uploading files to a backend API (DirectLink) that returns direct download links. The frontend handles file selection via drag-and-drop or file input, uploads with progress tracking, and maintains a history of uploaded files stored in localStorage. It uses valtio for reactive state management, Material UI and styled-components for styling, and axios for HTTP requests with retry logic. The application is cleanly structured with reusable custom hooks (useUnmountEffect, useProxyState) and a portal-based dialog system (DialogContainer). The backend is a separate binary not included in this repository. The codebase demonstrates modern frontend engineering with good separation of concerns and moderate complexity.
Mage is an open-source data pipeline orchestration platform that combines a visual notebook-style editor with a production-grade scheduling and execution engine. The system enables users to build, run, and monitor data pipelines composed of Python, SQL, R, and dbt blocks. Architecturally, it is a full-stack web application with a Python backend (Tornado-based server, SQLAlchemy ORM, REST API) and a Next.js/React frontend with a custom component library. Key entry points include the CLI (`mage` command), the web UI served by `mage_ai/server/server.py`, and the API layer at `mage_ai/api/` which exposes CRUD resources for pipelines, blocks, runs, schedules, users, and integrations. Data flows center around pipeline execution: blocks are connected in a DAG, each block can be a data loader, transformer, or exporter. Execution is handled by a configurable executor (local, K8s, EMR, PySpark) and scheduled via a built-in scheduler or external triggers. The platform integrates with dozens of data sources and destinations through a Singer-based integration framework, supports streaming pipelines, and includes advanced features like RBAC, version control, AI-assisted pipeline generation, and a command center for global search. It depends heavily on external services such as cloud storage (S3, GCS, Azure), databases (PostgreSQL, BigQuery, Snowflake, etc.), and authentication providers (OAuth, LDAP, OIDC).
This repository is a clean-room reimplementation of the C64/C65/MEGA65 system ROMs, written primarily in 6502 assembly. It produces binary ROM images (e.g., `mega65_orfont.rom`, Kernal/BASIC ROMs) that can be flashed to hardware or used in emulators. The codebase is organized as a firmware source tree rather than a runtime application: `src/` contains the ROM source, `tools/` contains C/C++ utilities for verification and constant generation, and `testsuite/` contains TAP/D64 disk and tape images used as regression fixtures. The build is driven by platform-specific `config_*.s` files that select memory models and feature sets. It implements standard system software: a Kernal jump table, BASIC interpreter, machine-code monitor, keyboard scanner with debounce/repeat, tape/disk I/O, and a Z80 VM for CP/M compatibility. The project uses clean-room methodology: a similarity tool compares the new ROMs against original ROMs to detect accidental copying, and floating-point constants are generated from documented values rather than disassembled code. The test suite validates tape loading and disk access using standard `.tap` and `.d64` formats. Maintenance is active, but the codebase shows some internal drift: many `config_*.s` flags are not always consistent, and some modules carry WIP markers. The project is highly specialized to 6502-based retro platforms; most source is not portable outside that niche. However, several tools and patterns (binary similarity checking, code generation from specs, jump-table APIs, self-contained monitor) are reusable in other firmware or emulation projects.
MaxKey is a comprehensive Identity and Access Management (IAM) and Single Sign-On (SSO) platform written in Java (Spring Boot) with Angular frontends. It implements a wide range of federation protocols including OAuth 2.0/OpenID Connect, SAML 2.0, CAS, JWT, form-based, token-based, and custom ExtendApi. The system provides enterprise identity management features such as user/group/role management, multi-factor authentication (TOTP, SMS, email), password policies, social login integration, LDAP/Active Directory authentication realms, and identity synchronization with external directories (LDAP, Feishu, WorkWeixin, DingTalk). The architecture is modular: a set of shared libraries (maxkey-commons, maxkey-entity, maxkey-persistence) support multiple web applications—a user-facing SSO portal (maxkey-web-maxkey), an admin management console (maxkey-web-mgt), a REST API (maxkey-web-openapi), and a SCIM 2.0 provisioning API. Two Angular applications (maxkey-web-ng and maxkey-web-mgt-ng) provide the frontend interfaces, built on the ng-alain/Delon framework with ng-zorro-antd. The system relies on MySQL/PostgreSQL for persistence, Redis for distributed caching and ticket storage, and supports Docker deployment with Nginx reverse proxy. Key data flows include authentication via pluggable providers (normal, mobile, trusted, MFA, certificate, WS-Federation, Kerberos), authorization through OAuth2/SAML/CAS protocol endpoints, and identity synchronization via scheduled jobs. The codebase is actively maintained but shows signs of technical drift: duplicated frontend code between the two Angular apps, some deprecated library usage (Velocity, old OpenSAML), hardcoded credentials in test/configuration files, and a mix of JPA and MyBatis persistence patterns that increase complexity.
IgGM is a generative foundation model for antibody and nanobody design, implemented as a deep learning library with a command-line interface. The system performs tasks such as CDR loop design, framework region redesign (humanization), inverse design from complex structures, affinity maturation, and structure prediction. It uses a diffusion-based approach to co-design amino acid sequences and 3D backbone structures, leveraging an ESM2-based protein language model, Evoformer blocks with triangular attention, invariant point attention, and a structure module similar to AlphaFold2. The pipeline is orchestrated by the `AbDesigner` class and invoked via the `design.py` script, accepting PDB and FASTA inputs and generating output sequences and structures. The repository includes well-structured reusable components for rigid-body transformations (Rotation, Rigid), PDB parsing, coordinate conversion, and diffusion schedules, though some research artifacts (misspellings, commented code) and dependency pinning to older PyTorch/CUDA versions indicate moderate technical drift.
This repository is a monorepo of self-contained demo applications showing how to build and deploy multi-agent AI systems using Docker Compose, Docker Model Runner, and the MCP Gateway. It contains 12+ independent examples spanning Google ADK, A2A, Agno, CrewAI, LangGraph, Langchaingo (Go), Spring AI, Akka, and a Next.js agent UI. Each subproject is a standalone composition with its own compose.yaml, Dockerfile, and README, designed to run with a single `docker compose up --build` after creating a `.mcp.env` file. The demos are reference architectures rather than a single product, emphasizing local LLM inference, MCP tool integration, and switching between local and cloud models via compose override files.
Handwrite is a CLI application that converts a scanned handwriting sample into a TrueType font. The pipeline consists of three stages: SHEETtoPNG uses OpenCV to detect and extract individual character images from a grid-based form; PNGtoSVG uses Potrace to convert the PNG images to SVG vector outlines; and SVGtoTTF uses FontForge to compile the SVGs into a font file with configurable metrics, kerning, and bearings. The architecture is a simple sequential pipeline orchestrated by the CLI entry point. External dependencies include OpenCV, Pillow, Potrace, and FontForge. The codebase is well-structured with unit tests, CI, and modern Python packaging (uv, Python 3.14). The character detection module in `sheettopng.py` demonstrates reusable grid-based contour extraction logic.
This repository is a curated resource catalog for WeChat Mini Program development. It does not build a deployable application in the traditional sense; instead, it operates as a structured data project that generates a searchable static site and API from a YAML data file. The core architecture is a set of TypeScript scripts that read `data/resources.yaml`, validate the data integrity, check external links for liveness, and generate `README.md`, `public/api/resources.json`, and the search interface in `public/index.html`. The data is categorized into official docs, tools, plugins, components, backend SDKs, and demos, each with metadata like language, difficulty, and topics. The repository's primary value lies in its data quality tooling. The validation script (`validate-data.ts`) enforces strict schema rules, checks for duplicate URLs, validates metadata, and provides precise YAML line numbers for errors. The link checker (`check-links.ts`) uses concurrent HTTP requests with retries and graceful handling of servers that block HEAD requests. The import script (`import-readme.ts`) can reconstruct the YAML from the generated README, enabling a bidirectional workflow. The GitHub Actions CI pipeline runs validation, generation checks, and link checks on pull requests, posting automated comments when checks fail. The codebase is well-structured with clean separation of concerns: `catalog.ts` handles all data types and YAML/JSON I/O, `generate.ts` handles README and API generation, and individual scripts handle specific tasks. The TypeScript configuration uses strict mode and modern ES2022 features. Dependencies are minimal (only `yaml` at runtime) and the project requires Node.js >= 20. The last commit was in June 2026, indicating the project is in a stable but not actively developed state.
AzGovViz (Azure Governance Visualizer) is a PowerShell 7+ application that performs deep Azure governance reconnaissance: it traverses an Azure tenant's Management Group hierarchy and collects policy, RBAC, Blueprint, diagnostic, cost, network, storage, orphaned-resource, and model-deployment data via ARM REST APIs, Microsoft Graph, and Azure Resource Graph. It renders results as an interactive HTML report (built on AG Grid), plus CSV, Markdown, and full JSON exports for change tracking. Architecturally it is a single generated ~39k-line PowerShell script (pwsh/AzGovVizParallel.ps1) assembled by a build script from modular function files under pwsh/dev/functions/. It is designed for scheduled, unattended execution in Azure DevOps or GitHub Actions using OIDC or service principal authentication, and can also run from a console or an Azure Web App accelerator. Data collection is heavily parallelized with ForEach-Object -Parallel, synchronized hashtables, and batched API calls with caching. It is not a library or service; it is a batch CLI reporting application, though its output artifacts form a structured analysis dataset. Notable non-trivial engineering includes dictionary-based HTML compression to keep report sizes within GitHub file-size limits, streaming JSON generation to avoid out-of-memory failures on huge tenants, parallel cost and ARG query batching, and an ALZ policy version checker that walks git history of the Azure Enterprise-Scale repository to hash and track policy drift. The trade-off is significant monolith complexity, heavy reliance on global script state, hardcoded API versions, and dependencies on external CDNs for interactive table libraries.
The repository is a full-stack application template providing role-based access control (RBAC) with a modern frontend and multiple backend options. It features a React/Vite frontend built with Shadcn UI and Tailwind CSS, offering comprehensive UI components, dashboards, and charting capabilities. Two backend implementations are provided: Spring Boot (Java) and NestJS (TypeScript), both featuring JWT authentication, PostgreSQL integration, and CRUD operations for users, roles, permissions, and groups. The frontend showcases a well-crafted component library including reusable UI primitives, custom extensions like tree selectors and context menus, and themed chart containers. State management is handled via Zustand, with internationalization via react-intl and API mocking using MSW. The backends follow standard layered architectures with service-repository patterns, DTO validation, and security configurations. While the Spring Boot backend contains a non-standard Java 25 version specification (likely a typo) posing build risks, the NestJS backend uses current LTS Node.js versions. The project demonstrates solid full-stack engineering with modular design, clear separation of concerns, and reusable UI patterns. Despite the Java version concern in one backend, the template remains a valuable foundation for enterprise admin panels with modern tooling.
PythonRobotics is a large collection of robotics algorithms implemented in Python, designed primarily for educational purposes and as a companion to a textbook. It covers a wide range of robotics domains including localization (EKF, particle filter, histogram filter), mapping (grid maps, NDT, clustering), SLAM (EKF SLAM, FastSLAM, GraphSLAM), path planning (A*, Dijkstra, RRT variants, PRM, DWA, Frenet, etc.), path tracking (Stanley, LQR, MPC, pure pursuit), arm navigation (inverse kinematics, RRT for arms), aerial navigation (drone trajectory, rocket landing), bipedal walking, inverted pendulum control, and mission planning (state machines, behavior trees). Each algorithm is implemented as a standalone script with a main() function that runs a simulation and visualizes results using matplotlib. The code is not packaged as a library and is not intended for production use; it is a learning resource with clear, readable implementations that reference academic papers. The repository includes extensive documentation in Sphinx RST format, CI/CD pipelines, and a test suite that runs each demo without animation.
This repository provides a comprehensive collection of 52 specialized AI agent prompts for penetration testing, integrated with a SQLite findings database, installer, and Claude Code CLI commands. It is designed to work with Anthropic's Claude Code and other compatible LLM environments. The system includes agent definitions covering reconnaissance, exploitation, post-exploitation, detection, and reporting, with mandatory scope enforcement and dual offensive/defensive perspectives. Supporting infrastructure includes a robust bash installer, a findings database CLI for persisting engagement data across sessions, slash commands for task routing (`/recommend`, `/agents-for`, `/memory`), and a CI pipeline for validation. While not a traditional application, it functions as a tool-integrated prompt pack with some executable shell scripts. The repository is actively maintained with an extensive coverage matrix mapping to MITRE ATT&CK techniques. Notable reusable components include the findings database CLI (`db/findings.sh`), a shared SQLite utility library with fallback support (`db/lib/common.sh`), and the scope-guard safety prompt pattern (`agents/_scope-guard.md`). The codebase is well-structured for its purpose but is primarily a prompt library rather than software with complex runtime logic.
This repository provides the `starred` Python CLI tool, which generates and maintains an Awesome-style Markdown list from a GitHub user's starred repositories. The tool queries the GitHub GraphQL API to fetch all starred repos (with pagination), groups them by programming language or repository topic, and outputs a formatted Markdown document. It can optionally sort categories alphabetically, filter by topic popularity, include private repositories, and directly push the generated file to a target GitHub repository using the GitHub REST API. The architecture is a simple single-command CLI with two source modules: `starred/starred.py` (Click CLI entry point and Markdown generation) and `starred/githubgql.py` (a self-contained GraphQL client for fetching starred repos). External dependencies include `click`, `requests`, `github3.py`, `gql`, and `aiohttp`. The code is clean, follows a straightforward functional design, and integrates well with GitHub's APIs. While it lacks unit tests, the CI runs an integration test against the real GitHub API.
This repository is the official 1Panel app store: a versioned catalog of deployable self-hosted applications packaged as metadata manifests (data.yml), Docker Compose templates, init/upgrade shell scripts, and localized READMEs. It contains no product source code; it is infrastructure-as-code consumed by the 1Panel server panel to render installation forms, provision containers, and perform upgrades. Apps span databases, runtimes, AI/LLM tools, monitoring, web servers, CMS, CI/CD, and cluster templates, each following the same env-var convention (PANEL_APP_PORT_*, PANEL_DB_*, PANEL_REDIS_*), external 1panel-network attachment, and createdBy: "Apps" labels.
yewtube is a terminal-based YouTube player and downloader, forked from mps-youtube. It provides a full-featured CLI for searching, streaming, downloading, and managing YouTube content without requiring a YouTube API key. The application uses yt-dlp and youtube-search-python as backends for video extraction and search. It supports multiple media players (mpv, mplayer, VLC), MPRIS integration for desktop media control, Last.fm scrobbling, playlist management (local and YouTube), and various download/transcoding options. The architecture is a monolithic Python application with a command-loop pattern, global state management via a dedicated module, and a plugin-like player abstraction. While the codebase shows its age with some tightly coupled modules and global variables, it contains well-designed components such as a config system with validation, an abstract player interface, and a command registration decorator. The project is actively maintained with recent commits and releases.
Material Files is a sophisticated, open-source Android file manager built with Kotlin and Material Design principles. Its core architecture is a custom implementation of the Java NIO2 file system API (`java.nio.file.spi.FileSystemProvider`), providing a unified abstraction over multiple backends: the local Linux filesystem (accessed via JNI syscalls), Android's proprietary Documents/Content providers, and remote network protocols including SMB, SFTP, FTP, and WebDAV. The UI is constructed from Android Fragments, RecyclerView adapters, and custom Material Design widgets, orchestrated by a ViewModel/LiveData pattern for reactive state management. The application goes far beyond basic file browsing. It features a comprehensive background file job service for copy, move, delete, and archive operations with progress tracking and conflict resolution. It includes a built-in FTP server, an image viewer with EXIF support, a text editor, and deep file property inspection (APK metadata, audio/video tags, checksums, POSIX permissions, and SELinux context). Root access is achieved through a separate process communicated via AIDL (Android Interface Definition Language), demonstrating a sophisticated IPC architecture for privilege escalation. The codebase is actively maintained by a single developer, with recent commits and a clear version history. However, it suffers from high technical drift due to its heavy reliance on Android's internal, undocumented, and frequently changing APIs (e.g., `android.system`, `android.os.storage`). The extensive `compat` package is a testament to the constant battle against platform evolution. This makes the project fragile and high-risk for long-term maintenance without dedicated effort. Despite its overall complexity, the repository contains several genuinely reusable, high-craftsmanship components. Standouts include the `ByteString`/`ByteStringPath` classes for handling non-UTF-8 filesystem paths, a generic `ListDiffer` algorithm, a robust `Stateful`/`DataState` state machine pattern, and clean implementations of throttling/debouncing. These components are self-contained and could be extracted for use in other Kotlin or Java projects. The overall quality score is 7.5, reflecting strong engineering and feature depth, balanced against significant platform-specific technical debt.