butterchurn is a browser-based, real-time music visualizer that faithfully reimplements the classic MilkDrop visualizer using WebGL2. It consumes audio from the Web Audio API, runs FFT analysis to derive frequency/amplitude data, and drives a shader-based render pipeline from JSON presets that encode MilkDrop-style equations. The core library exposes a minimal `createVisualizer()` entry point, after which consumers load a preset and call `render()` with audio level data each animation frame. The library supports two equation execution paths: a JS-based expression runner and a WebAssembly/AssemblyScript-based EEL runner, with a custom Rollup plugin that compiles AssemblyScript to base64-encoded WASM at build time. It also includes deterministic seeded RNG for reproducible rendering, which is used by its visual regression test suite to compare JS and WASM paths pixel-for-pixel across a curated set of presets.
B3DFramework is a large, MIT-licensed C++ game engine and real-time application framework, derived from the Banshee Engine codebase and still carrying many legacy `bsf`-prefixed module names. In production it provides a full game-development stack: a hybrid tiled-deferred/clustered-forward renderer with Vulkan, D3D12, and Metal backends; PhysX-based physics; OpenAL/FMOD audio; a comprehensive GUI toolkit; animation, particle, resource/importer, and scene/prefab systems; plus a Mono-based C# scripting layer with hundreds of generated interop wrappers. The engine is plugin-oriented, with renderers, GPU backends, physics, audio, and importers all loadable as dynamic libraries or statically registered modules, and it supports Windows, Linux, and macOS platform code. It also includes a headless/null backend path for CI and automated testing.
Pyroomacoustics is a Python library for room acoustics simulation and audio array signal processing. It provides a modular framework for creating virtual acoustic environments (rooms with walls, materials, sources, and microphone arrays) and simulating room impulse responses using both image-source and ray-tracing methods, with a C++ backend for performance. Beyond simulation, it offers a comprehensive suite of audio processing algorithms: beamforming (delay-and-sum, MVDR, rake filters), direction-of-arrival estimation (MUSIC, SRP-PHAT, FRIDA, CSSM, TOPS, WAVES), blind source separation (AuxIVA, ILRMA, FastMNMF, TRINICON), adaptive filtering (NLMS, RLS, subband LMS), and noise reduction (spectral subtraction, subspace, iterative Wiener). It also includes directivity modeling (analytic patterns and measured SOFA data), STFT/DFT transforms with multiple backends, and utility modules for resampling, filterbanks, and metrics (RT60, PESQ). The library is designed for research prototyping and reproducible experiments, with extensive unit tests and CI/CD for multi-platform builds.
This repository is the canonical reference implementation of ERC-4337 (Ethereum Account Abstraction) by the standard's authors. It provides a singleton EntryPoint contract that coordinates validation, execution, and gas accounting for UserOperations. The codebase includes abstract base contracts for accounts and paymasters, production-grade sample accounts (SimpleAccount, Simple7702Account), libraries for packed UserOperation hashing and EIP-7702 support, and extensive test and simulation infrastructure. It is deployed on Ethereum mainnet and supports paymasters, signature aggregators, counterfactual deployment via CREATE2, and EIP-7702 delegated code. The architecture is modular: core logic is separated into libraries (UserOperationLib, Helpers, Exec, Eip7702Support) and abstract contracts (BaseAccount, BasePaymaster, StakeManager, NonceManager) that can be reused in custom implementations. Gas optimization is a key focus, with patterns like transient storage, packed storage, and a custom nonReentrant guard. While the repo is tightly coupled to the EntryPoint's design, individual libraries and base contracts are reusable in any ERC-4337 integration.
Aura is a command-line package manager for Arch Linux and the Arch User Repository (AUR). It acts as a drop-in replacement for pacman, passing all pacman operations through unchanged while adding AUR-specific workflows: searching and building packages from the AUR, maintaining a local package cache for downgrades, taking JSON snapshots of installed package state for rollback, viewing and searching ALPM logs, identifying orphaned packages, analyzing licenses, and generating dependency graphs. The system integrates directly with pacman, makepkg, git, sudo/doas, shellcheck, and Graphviz, and uses a custom FAUR metadata server to query AUR package data efficiently. The primary implementation is a modern Rust workspace (aura-pm binary, aura-core library, and r2d2-alpm connection pool), with extensive localization via Project Fluent covering more than 20 languages. A legacy Haskell implementation remains in the repository but is superseded by the Rust rewrite, which is the actively maintained codebase.
Apache Kudu is a distributed columnar storage system designed for fast analytics on fast data. It provides a combination of fast insert/update and efficient columnar scans, filling the gap between HDFS (batch) and HBase (random access). The architecture consists of master servers (for metadata, catalog, and coordination) and tablet servers (for data storage and retrieval), using Raft consensus for replication and fault tolerance. It supports transactions, security (Kerberos, TLS, Apache Ranger), and integration with Apache Spark, Impala, Flink, and Hive Metastore. The codebase includes a C++ core with a rich set of utilities, a Java client library, a Python client, and various CLI tools for administration and debugging. It is a production-grade system with extensive testing, benchmarking, and performance optimization infrastructure.
This repository is a template for creating Android/Kotlin applications. It provides a multi-module Gradle project with an Android app module, Android library module, Jetpack Compose library module, and pure Kotlin library module. The template includes standardized configurations for dependency management via Version Catalog, static analysis with detekt/ktlint, CI/CD pipelines using GitHub Actions, and publishing to Maven Central. Key features include a factorial calculation example demonstrating inter-module communication, navigation between traditional Android Views and Jetpack Compose, and automated template cleanup functionality for forked repositories. The architecture follows Android best practices with clear separation of concerns and modern Android development tools.
Murex is a cross-platform shell and scripting language designed as a more readable, safe, and type-aware alternative to Bash. In production it works as both an interactive REPL (with autocomplete, hint text, preview panes, spellchecking, and job control) and a scripting interpreter with a custom expression language, typed pipelines, exception handling (try/catch/trypipe), multi-scope variables, a built-in unit test framework, event hooks (onPrompt, onKeyPress, onFileSystemChange, onSignalReceived), an HTTP client, and a package/module manager. The defining architectural feature is that data in pipelines carries type metadata: JSON, YAML, CSV, TOML, XML, S-expressions, HCL and more are first-class structured objects with registered Marshal/Unmarshal/ReadArray/ReadMap/ReadIndex hooks, so builtins like alter, tabulate, count, and jsplit operate on structured data rather than raw text. The implementation is Go (with a JS/WASM interpreter variant), organized around lang/ (parser, expression engine, process lifecycle), shell/ (interactive terminal layer), builtins/ (roughly 200 commands, data type adapters, pipes, and event handlers), config/ (profile-driven runtime configuration), and utils/ (standalone helper libraries).
ember-simple-auth is an Ember.js addon that provides client-side session management and pluggable authentication strategies for single-page applications. In production it maintains an authenticated session, persists it across tabs/windows via interchangeable session stores (localStorage, sessionStorage, cookie, ephemeral, and an adaptive fallback), and coordinates it with pluggable authenticators covering OAuth2 password grant, OAuth2 implicit grant, Devise, Torii, and a test authenticator. The main public API is the SessionService with authenticate, invalidate, setup, requireAuthentication, and prohibitAuthentication, backed by an InternalSession state machine that handles persistence, event delegation, and redirect targets. Architecturally, this is a classic Ember library with a small core and deliberate extension points. Applications subclass authenticators and session stores, override service factory hooks such as createConfiguration, createSessionStore, and createAuthenticators, and can opt out of Ember's resolver for more controlled composition. The monorepo includes the addon package, two consumer test apps, Playwright end-to-end tests, FastBoot support, and a docs site. The addon explicitly supports engines and server-side rendering, with the cookie store required for FastBoot. Maintenance is active: CI covers multiple Ember versions from LTS through canary, plus linting, unit tests, FastBoot tests, and Playwright browser tests. The codebase is undergoing a TypeScript migration and preparing for a v9 release, so some modules remain JavaScript and a few compatibility shims are intentionally present. The overall architecture is clean and mature, though consumers should validate their Ember version against the addon's transitional deprecation timeline.
Vexip UI is a large, TypeScript-first Vue 3 component library with over 78 high-quality components, built as a monorepo with multiple internal packages (`@vexip-ui/utils`, `@vexip-ui/hooks`, `@vexip-ui/config`, `@vexip-ui/icons`, `@vexip-ui/bem-helper`, etc.). It provides a consistent prop system via `useProps`, BEM-based theming, extensive composable hooks, custom directives, and a global configuration provider. The codebase is actively maintained, with comprehensive unit and SSR tests, bilingual documentation (VitePress), and a playground. It follows modern Vue 3 patterns (Composition API, JSX/TSX, TypeScript generics) and demonstrates strong engineering practices in component architecture, state injection, and performance (virtual scroll, lazy rendering, resize observers). While heavily coupled internally, many of its building blocks (e.g., BEM helper, PostCSS plugin, utility functions) are published as standalone packages and are reusable in other Vue projects.
SmartNode is a satellite relay simulation platform for space-based data backhaul, combining a Flask REST API backend with a Vue 3 frontend that visualizes satellite constellations on a Cesium 3D globe. It simulates LEO/MEO/GEO satellites, ground stations, and relay links, processing data transmission requests with configurable QoS, security, and value profiles. The backend implements orbital propagation (SGP4/TLE, Keplerian elements), ITU-R link budget models (rain attenuation, gaseous absorption, laser ISL), and scheduling strategies (GreedyMaxRate, QoS-aware admission control, handover with hysteresis). Results are persisted in SQLite and an append-only event log, with real-time updates pushed via SSE. The platform includes a full observability stack (Prometheus, Grafana, OpenTelemetry), containerized deployment, and extensive testing (unit, integration, property-based, golden regression, load). While primarily an application, it incorporates significant data/research components in orbital mechanics, communications, and scheduling algorithms, making it a hybrid but application-dominant project.
This repository provides a two-skill workflow system for academic paper creation designed to work with Claude Code. The 'academic-paper-strategist' skill handles research planning through platform analysis, literature search, gap identification, and outline optimization with quality gates. The 'academic-paper-composer' skill executes systematic writing from outlines with chapter-level quality checks and final evaluation. The system emphasizes quality control through structured rubrics and iterative validation, transforming research ideas into submission-ready manuscripts with comprehensive quality reports. While primarily documentation-heavy, it contains several self-contained, reusable evaluation systems that demonstrate sophisticated assessment frameworks.
This repository implements a fully offline, multi-modal translation application for Android. It supports text translation, image translation via OCR (PaddleOCR, Tesseract), document translation (PDF, ODT, EPUB, TXT), live camera translation with GPU-accelerated overlay, screen capture translation, a built-in web browser with adblock and reader mode, text-to-speech (Piper, Kokoro, MMS, Coqui, Mimic3), and dictionary lookup from Wiktionary data. All inference runs on-device using downloaded language packs (translation models, OCR models, TTS voices, dictionaries). The app is built with Kotlin and Jetpack Compose for the UI, with a native Rust core (via UniFFI and JNI) for performance-critical tasks like translation, OCR, TTS synthesis, and GPU rendering. It also includes a Python-based catalog generation pipeline for managing model distributions and a standalone i18n viewer tool for translation management. The architecture is a monolith with multiple foreground services, accessibility services, and overlay windows, all orchestrated by a central ViewModel and a Rust-based catalog handle. While primarily an application, the repository also contains data/research elements in the form of model catalogs, evaluation metrics, and build-time data processing scripts.
Hexabot is a full-stack conversational AI platform for building and managing agentic chatbots with workflow automation. The system provides a visual workflow editor (based on xyflow) for designing multi-step flows, supports multiple messaging channels (web, console, and extensible), integrates with AI models via the Vercel AI SDK and Ollama, and includes a CMS with RAG (Retrieval-Augmented Generation) capabilities. It also features a memory system for context persistence, MCP (Model Context Protocol) integration for external tool discovery, audit logging with pluggable backends, analytics dashboards, and license enforcement via Lemon Squeezy. The architecture is a monorepo with seven packages: `api` (NestJS + TypeORM backend), `frontend` (React + MUI admin panel), `widget` (embeddable chat widget), `cli` (project lifecycle management), `agentic` (core workflow engine with DSL and step executors), `graph` (reusable workflow graph component), and `types` (shared Zod schemas). Key entry points include the API bootstrap (`main.ts`), the frontend app (`main.tsx`), the widget (`ChatWidget.tsx`), and the CLI (`index.ts`). Primary data flows involve inbound messages from channels being routed through the channel service to the workflow engine, which executes actions (AI generation, messaging, web requests, etc.) and produces outbound responses. External dependencies include PostgreSQL/SQLite, Redis (optional), Vercel AI SDK, MCP servers, and Lemon Squeezy for licensing. The codebase demonstrates strong engineering practices with generic CRUD abstractions, dynamic provider injection for extensions, Zod-based validation and JSON Schema generation, and a sophisticated graph layout engine. It is actively maintained with a comprehensive test suite and CI/CD pipelines.
SimUtil is a Dart-based terminal UI/CLI for managing iOS simulators and Xcode Derived Data. It wraps `xcrun simctl` to list, boot, shut down, install, launch, and interact with simulator devices, and adds conveniences like showing/cleaning Derived Data. The app is operated entirely from the terminal and stores user preferences in `~/.simutil/settings.yaml`, including a `plugins:` section for custom commands. Architecturally it separates terminal UI components (`lib/components`) from services (`lib/services`) such as `CommandExec` (a shell-command abstraction), `UserConfig` (YAML settings with first-run defaults and scalar merge), and Derived Data helpers. A `tool/generate_changelog.dart` code generator parses `CHANGELOG.md` and emits typed Dart data so the app can show post-update changelog dialogs. Tests cover the changelog generator and config file behavior, and CI runs build/install verification across platforms.
This repository is a monorepo for **ytmdesktop2**, an unofficial Electron desktop client for YouTube Music. It wraps the YouTube Music web player and enhances it with deep native OS integration, including system tray controls, media key support, Discord Rich Presence, Last.fm scrobbling, Chromecast streaming, custom CSS/SCSS theming, OBS Studio overlays via a local HTTP/WebSocket API, and an Elgato Stream Deck plugin. The architecture is a monolithic Electron application with a clear separation between the main process (Node.js services, tRPC server), the renderer process (React settings UI), and page-world plugins that interact directly with the YouTube Music DOM. Communication between these layers is handled through a combination of tRPC, typed postMessage bridges, and raw IPC. The codebase demonstrates high craftsmanship in several areas, particularly its multi-provider synced lyrics engine (parsing LRC, TTML, and YouTube captions), its embeddable widget system for OBS, and its robust plugin lifecycle management. While the project is actively maintained and well-structured, it carries significant technical debt from its deep coupling to YouTube Music's internal DOM and APIs, which are subject to change. The coexistence of two major Zod versions and some deprecated migration paths indicate ongoing refactoring. Overall, it is a sophisticated and feature-rich desktop application that effectively bridges a web service with the native desktop environment.
Matcha is a full-featured terminal email client (TUI) written in Go, using the Bubble Tea framework. It supports multiple email protocols (IMAP, JMAP, POP3, Maildir) and provides a rich set of features including PGP/SMIME encryption, OAuth2 authentication, a Lua plugin system with 35+ community plugins, background daemon for push notifications and sync, spellcheck, i18n with 11 languages, and a configurable theme system. The architecture is modular: a backend provider interface abstracts protocol implementations, a daemon runs as a background process communicating via JSON-RPC over Unix sockets, and the TUI is built with composable Bubble Tea models. The codebase demonstrates strong engineering practices with extensive test coverage, CI/CD pipelines, cross-platform packaging (Homebrew, Snap, Flatpak, Nix, WinGet), and a well-designed plugin API. It is not a data research project; it is a production-grade application.
PicoGK is a compact, open-source computational geometry kernel developed by LEAP 71 for engineering design and additive manufacturing. It provides a C# API over a high-performance native voxel engine (OpenVDB). The core abstraction is the Signed Distance Field (Voxels), supporting boolean operations, offsets, shells, lattice generation, implicit modeling, and meshing. It includes a robust 3D viewer, industry-standard IO (STL, VDB, CLI), and utilities for slicing and cross-section visualization. While primarily a library, its numerical core and debugging utilities carry a strong data-processing character.
Secureblue is a security-hardened Linux distribution project built on Fedora Atomic (Silverblue, Kinoite, Sericea, Cosmic, IoT, and SecureCore variants). It produces bootable OCI container images via BlueBuild recipes and GitHub Actions CI, applying extensive hardening: kernel module blacklists, hardened kernel arguments, sysctl tuning, SELinux policy enforcement, systemd service lockdowns, setuid removal, secure boot with UKI signing, and DNS hardening. The runtime includes a comprehensive audit tool (audit_secureblue.py) that verifies security posture across ~30 categories with i18n support, plus interactive ujust commands for toggling hardening features.
Nametag is a personal relationships management application that combines contact tracking, relationship visualization, journaling, and synchronization capabilities. Built with Next.js 16, React 19, and TypeScript, it features a modular architecture with API routes, Prisma ORM with PostgreSQL, and extensive third-party integrations including Stripe for billing, Resend for email, and CardDAV for address book synchronization. The application offers both self-hosted and SaaS deployment options with tiered feature access (FREE/PERSONAL/PRO). Key architectural strengths include isolated utility modules, consistent API patterns, soft delete implementation, and comprehensive testing coverage. The codebase demonstrates modern development practices with attention to security, internationalization, and data privacy.