The Ember Inspector is a browser extension (Chrome, Firefox, Opera) and bookmarklet for debugging Ember.js applications. It injects a debug library (`ember-debug`) into the inspected page to introspect runtime state — component trees, route trees, Ember Data models, render performance, promises, deprecations, and object properties — and displays this data in a developer tools panel built as an Ember.js application (`ember-inspector`). The architecture follows a clear messaging pattern: a `Port` abstraction (base class with adapters for each browser/transport) handles bidirectional communication between the injected debug script and the UI panel. Debug modules (e.g., `view-debug`, `route-debug`, `promise-debug`, `object-inspector`) extend a common `DebugPort` class. The UI uses Ember controllers, components (including a virtual-scrolled `InspectorTable`), and services for layout, storage, and port management. The codebase is professionally structured and includes extensive acceptance, integration, and unit tests across multiple Ember versions using `ember-try`. However, it relies heavily on Ember's private/internal APIs (e.g., `Ember.meta`, `_backburner`, `debugRenderTree`) and contains deprecated patterns (classic class syntax, `@observes`), leading to moderate technical drift and maintenance risk as Ember evolves.
AppUpdater is a multi-module Android library that provides in-app update functionality: it checks a remote version, downloads the APK, shows progress via notification or dialog, and installs the APK across Android versions. The core `app-updater` module contains the update orchestration, download/install services, notification handling, and file/checksum utilities; the `app-dialog` module provides a ready-made update dialog; the `app` module is a sample. The main entry point is the `AppUpdater` builder/facade, which accepts an `UpdateConfig` and optional custom parser/strategy implementations, so consumers can plug in their own update-info JSON schema.
janus is a Python library that provides mixed sync-async queues for communication between threaded code and asyncio code. The core architecture centers on a single `Queue` class that internally manages both synchronous and asynchronous interfaces via proxy objects (`_SyncQueueProxy` and `_AsyncQueueProxy`). It uses thread-safe conditions (`threading.Condition`) for sync operations and asyncio conditions (`asyncio.Condition`) with careful cross-thread notification via `loop.call_soon_threadsafe`. The queue supports standard FIFO, LIFO (`LifoQueue`), and priority (`PriorityQueue`) variants through a template method pattern (overriding `_init`, `_put`, `_get`). Lifecycle management includes graceful and immediate shutdown with dedicated exception types (`SyncQueueShutDown`/`AsyncQueueShutDown`) compatible with Python 3.13+. The library is production-stable, has no external dependencies beyond the standard library, and is thoroughly tested across multiple Python versions and concurrency scenarios. It does not expose APIs beyond queue operations and is strictly a communication primitive.
This repository is an official Nx example showcasing a micro-frontend architecture with two frontends: an Angular application for product browsing and a React application for a shopping cart, backed by a .NET minimal API. The code demonstrates cross-framework component reuse via custom elements (Web Components), multi-framework state management (NgRx for Angular, useReducer/Context for React), and Nx's monorepo capabilities including code generation, dependency graph, and CI/CD integration. Data is entirely static, with the .NET API used only for OpenAPI codegen; there is no runtime API consumption. The architecture is clean and modular, emphasizing Nx best practices for large monorepos.
This repository provides a server application for interacting with COMSOL Multiphysics models via a programmable interface. It features a modular architecture separating concerns into COMSOL model manipulation tools (geometry, mesh, physics, etc.), a knowledge base built from COMSOL documentation PDFs for retrieval-augmented generation, and utility functions for versioning and async handling. The system enables users to load, modify, and simulate COMSOL models through a server interface (likely MCP - Model Context Protocol), while leveraging a vector database of processed PDF documentation to provide contextual assistance. Key entry points include src/server.py and various domain-specific scripts in comsol_models/ directories for building and simulating specific models (e.g., solenoids, micromixers).
This repository contains a comprehensive hardware diagnostic and benchmarking tool implemented as a single bash script (hardware.sh). The tool collects detailed system information including OS, virtualization, motherboard, CPU, GPU, memory, and storage devices. It runs performance benchmarks using sysbench, fio, and Geekbench5 to evaluate hardware quality, presenting results in a formatted terminal interface with optional JSON output for further analysis. The script features robust dependency handling, automatic installation of missing tools, and cross-platform support for numerous Linux distributions. It demonstrates strong bash scripting practices with sophisticated progress bars, intelligent fallback mechanisms for network services, and modular design for gathering diverse system metrics.
A client-side single-page web application providing an interactive comparison tool for premium debrid services (AllDebrid, Real-Debrid, TorBox, Premiumize, etc.). It displays pricing, file host support (over 300 hosts), adult host support, usenet availability, and links to tools and community resources. The app is built with vanilla JavaScript (ES modules), Vite, and Workbox for offline support. Data is bundled as static JSON files directly imported at build time. The UI features searchable/filterable tables with lazy rendering, a side-by-side comparison module, dark mode, and responsive design. The codebase is well-structured, modular, and demonstrates good engineering practices including accessibility (ARIA labels, skip link, focus management), performance optimizations (content-visibility, skeleton loaders, debounced search), and a component lifecycle pattern for resource cleanup. It does not have tests or CI/CD pipelines.
This is an Ansible role and playbook collection that automates the hardened installation of the OpenClaw messaging gateway on Debian/Ubuntu Linux systems. It provisions a dedicated system user, installs Docker CE with UFW-based firewall and DOCKER-USER chain isolation, configures fail2ban and unattended-upgrades, sets up Node.js and pnpm, and installs OpenClaw either from npm (release mode) or from a Git checkout (development mode). The role does not configure the application or install its systemd service—those steps are left to the operator via `openclaw onboard --install-daemon`. It supports remote deployment via inventory and includes CI tests for syntax, linting, and integration. The codebase is well-structured, security-conscious, and actively maintained, though it does not contain independently extractable components suitable for reuse outside this project.
The OpenCode Browser plugin provides browser automation capabilities through direct connections to the Chrome DevTools Protocol (CDP). It exposes a set of tools (browser_list, browser_navigate, browser_snapshot, browser_click, browser_fill, browser_eval, browser_screenshot) that allow an AI agent to control a browser by specifying the browser's debugging endpoint (browser_url) and optionally a target ID. The plugin consists of three main parts: the plugin interface (src/plugin.ts), a lightweight CDP client over WebSocket (src/lib/cdp.ts), and accessibility tree snapshot utilities with unique element IDs for interaction (src/lib/snapshot.ts). The CDP client handles connection, message exchange, and event handling, while the snapshot utility processes the accessibility tree to generate a tree of nodes with stable UIDs for use in click and fill operations.
Steam Achievement Notifier (SAN) is a feature-rich Electron desktop application that monitors Steam and RetroAchievements unlock events and displays highly customizable on-screen notifications. It leverages the Steamworks API for real-time achievement tracking without requiring an API key, and integrates with RetroAchievements via emulator log file parsing. The application provides extensive customisation – multiple notification presets (consoles, Steam Deck, custom), per-type themes (colors, fonts, icons, glow, masks, positions), screenshot overlays, streaming overlays for OBS, Discord webhook posting, game completion timer, and a diagnostics troubleshooter. Architecture is multi-process: a main process handles window management and IPC, a renderer process displays the settings/customiser UI, a worker process continuously polls Steam for game state and achievements, and a RetroAchievements worker monitors emulator logs. Communication is event-driven with well-defined IPC channels. The project includes Rust native modules for keypress simulation, HDR screenshot capture, and high-performance process watchers, bundled as precompiled binaries. The codebase is actively maintained with regular releases, comprehensive localization (25+ languages), and detailed inline documentation (tooltips). While architecturally sound with clean separation of concerns, some modules (e.g., sanhelper.ts) are monolithic and tightly coupled to the application's config and UI, which may hinder isolated reuse. The translation files are large and duplicative, requiring coordinated updates across languages.
Jimmy is a command-line and terminal UI tool for converting notes from 50+ note-taking applications (Evernote, Obsidian, Joplin, Notion, Bear, etc.) into a unified Markdown format. It uses an intermediate representation (Notebook/Note/Resource/Tag objects) decoupled from input parsing and output writing, allowing clean extensibility. The architecture is a plugin-style converter framework with a rich set of format-specific parsers, markdown preprocessing libraries, and a resource deduplication system. The tool is distributed as standalone binaries bundling Pandoc and other dependencies. While the core abstractions are well-crafted, the vast majority of the codebase consists of tightly coupled format converters that are specific to each app's export schema, limiting general reuse. The project has extensive integration tests via a test data submodule, but many converters lack unit tests. Its requirement for Python 3.14 (a very recent version) and reliance on external binaries (Pandoc, one2html) introduce drift risks.
go-workflows is a Go library for building durable, fault-tolerant workflow applications. It implements an event-sourced execution engine inspired by Temporal/Cadence: workflows are modeled as histories of events, and workers execute them by replaying those histories against backend queues. The library exposes a public client API for starting, signaling, and waiting on workflows, and provides a workflow/activity authoring model with sub-workflows, timers, signals, retries, cancellation, and context propagation. Execution is built on a custom coroutine-based async runtime (internal/sync) that gives workflows deterministic control flow, and multiple storage backends (Redis, MySQL, PostgreSQL, SQLite, plus in-memory/monoprocess) implement the same backend interface. Key entry points include the client package, the worker package, the workflow/activity authoring packages, and the tester package for unit testing workflows without a real backend. The repository also contains a separate static analyzer module (analyzer/) that enforces workflow determinism at compile time, and a benchmark tool (bench/) for comparing backend performance. External dependencies include OpenTelemetry for tracing, slog for structured logging, and backend-specific drivers for Redis, MySQL, PostgreSQL, and SQLite. CI runs tests with the race detector across all backends, and Docker Compose provides the required databases. The codebase is substantial and well-tested, but carries maintainability debt: each backend duplicates significant logic (diagnostics queries, event insertion), Redis uses hand-written Lua scripts that can drift, and the embedded diagnostic web app requires a separate Node.js build step. The separate analyzer module also risks version drift from the main module. Despite these caveats, the core abstractions are clean and several components are genuinely reusable.
VeriFast is a research prototype tool for modular formal verification of correctness properties of single-threaded and multithreaded C, Java, and Rust programs. It uses separation logic to specify and verify properties such as memory safety, functional correctness, termination, deadlock freedom, and security properties. The tool provides frontends for multiple languages, an SMT-based verifier (primarily Z3), and an IDE. It has been applied to real-world code including Java Card applets, Linux kernel drivers, cryptographic protocols, and concurrent data structures. The codebase is well-structured with a core OCaml verifier, language-specific frontends (C/C++ via Clang, Rust via MIR, Java via bytecode), and a rich set of examples and test suites.
This is a Python library and CLI toolkit for processing, analyzing, and visualizing air traffic data. It provides core classes (`Flight`, `Traffic`, `Airspace`) for handling ADS-B trajectories, along with a rich set of algorithms for trajectory filtering, smoothing, navigation event detection (landing, takeoff, go-around, holding patterns), performance estimation (fuel burn, emissions via OpenAP), clustering (DBSCAN, GMM), closest-point-of-approach, trajectory generation, and simplification. Data can be ingested from multiple sources: the OpenSky Network (REST and Trino), Eurocontrol (AIXM, DDR), FAA, FlightRadar24, METAR, and embedded sample datasets. Visualizations are supported via matplotlib, Altair, Plotly, and Leaflet. A CLI subcommands (`show`, `data`, `cache`, `config`, `opensky`) provides interactive data access and caching. The architecture is a standard Python library with an optional web plugin (Tangram) for real-time landing alignment visualization. Although the primary character is an application/library, it also has strong research-oriented features, including published papers, gallery notebooks, and pre-trained ONNX models for holding pattern detection. The codebase is well-structured, modular, and includes a comprehensive test suite and CI/CD pipelines.
MeanFlow is a PyTorch implementation of a novel single-step flow matching model for high-quality image generation. The codebase provides a complete pipeline for training and evaluating SiT (Scalable Interpolant Transformer) models on ImageNet 256x256 and CIFAR-10, with a specific focus on achieving competitive FID scores in a single sampling step. Key components include a custom loss function with bootstrap and classifier-free guidance, a flexible time-sampling strategy, and distributed training/evaluation scripts using Accelerate. The repository also contains preprocessing utilities to convert ImageNet into VAE-encoded latent LMDB databases. While primarily a research codebase, it demonstrates strong engineering practices with clean module separation, EMA tracking, and comprehensive argument configuration. The implementation closely reproduces the MeanFlow paper results but requires significant computational resources (multiple GPUs, large storage) to run.
IntuneWin32App is a PowerShell module designed for managing Windows 32-bit line-of-business applications in Microsoft Intune. It automates the entire lifecycle of Win32 app management, including packaging applications into the .intunewin format, creating/updating/deleting apps in Intune via Microsoft Graph API, managing assignments (to groups, all users, or all devices), and handling relationships such as dependencies and supersedence. The module implements multiple OAuth 2.0 authentication flows (interactive, device code, client secret, and client certificate) without external dependencies, providing a self-contained solution for secure Graph API interactions. The architecture follows a modular PowerShell module pattern with clear separation of concerns: public functions (user-facing cmdlets) in the Public directory, private helper functions in the Private directory, and a central module manifest. Key entry points include Connect-MSIntuneGraph for authentication, New-IntuneWin32AppPackage for creating .intunewin packages, and various Add/Set/Get functions for app and assignment management. Data flows involve authentication token acquisition, optional app packaging, Graph API calls for app creation/modification, and subsequent assignment/relationship operations. The module relies on Microsoft Graph API endpoints, Azure AD for authentication, and optionally the IntuneWinAppUtil.exe tool for packaging. Notable engineering practices include consistent parameter validation, standardized error handling, reusable API communication logic with retry/pagination mechanisms, and a clean pattern for constructing JSON payloads using ordered hashtables. The module demonstrates significant effort in implementing native OAuth 2.0 flows and maintaining compatibility with evolving Intune features through regular updates.
This is an Android application that serves as a GUI client for XTLS/Xray-core, a proxy/VPN tool. The app provides a comprehensive interface for managing proxy profiles, subscription links, and VPN configurations. It supports both standard VPN mode (using tun2socks) and transparent proxy mode (requiring root). The architecture follows MVVM with Room database for persistence, coroutines for async operations, and a native Go library (XrayCore) for core proxy functionality. The codebase is well-structured, using modern Android development practices (Kotlin, Jetpack libraries, Material Design 3). It includes features like QR code scanning, clipboard import, link management with auto-refresh, per-app routing, and a quick settings tile. The app is actively maintained with frequent updates and a CI/CD pipeline for release builds.
Reall3dViewer is a high-performance 3D Gaussian Splatting (3DGS) web viewer built on Three.js. It streams and renders large-scale point cloud scenes (up to 150M points) at interactive frame rates across desktop and mobile devices. The viewer supports multiple input formats including PLY, SPLAT, SPX (proprietary high-compression format), SPZ, SOG, and GLB with the KHR_gaussian_splatting extension. Its architecture is event-driven and modular, with a central event system (Events.ts), dedicated loaders for each format, web workers for parallel data fetching and sorting, and a texture management pipeline that handles LOD tile streaming, frustum culling, and adaptive quality levels. Beyond basic viewing, the repository provides a full suite of interactive features: measurement and annotation tools (distance, area, point labels, 3D tags, circle plans), a map viewer (Reall3dMapViewer) with GIS basemap integration, a first-person/third-person player mode with physics (rapier3d), weather effects (rain, snow), audio-driven text overlays, and a fly-through camera path system. The code is published as an npm package (@reall3d/reall3dviewer) and includes comprehensive demo pages with scene configuration JSON files. While primarily an application library, the project also exhibits data/research characteristics through its custom SPX format specifications, advanced compression techniques (WebP, gzip, xz, zstd), and spherical harmonics support up to degree 3. The source code demonstrates high engineering craftsmanship in areas like GLSL shader modularization, WebAssembly integration for format parsing, and efficient web worker communication patterns. However, there are some maintenance risks including a large monolithic event constant file (200+ auto-incremented integers), hardcoded demo URLs, and a build script that embeds worker code as base64, which complicates debugging. No automated tests are present.
GEM is a Gym-like framework for training and evaluating agentic LLMs via reinforcement learning. It provides a diverse set of environments (games, math, code, QA, etc.) that can be used to train LLMs to interact with tools, solve problems, and make sequential decisions. The framework features a modular design with composable wrappers for observation modification, tool integration, and episode tracking, along with vectorized environments for parallel execution. It supports integration with multiple RL training frameworks (Oat, Verl, Tinker, OpenRLHF, RL2) through example scripts, making it a versatile tool for LLM agent research.
The `av` CLI tool manages stacked Git branches and their associated GitHub pull requests in an automated workflow. It allows developers to create dependent branches, automatically rebase child branches when parents change, synchronize local state with GitHub (fetches, pushes, prunes merged branches), and interactively reorder or squash commits across a stack. The system uses a local JSON file database (`av.db`) to persist branch metadata and PR associations, a GraphQL client to communicate with GitHub, and a Bubbletea-based terminal UI for interactive prompts and progress spinners. It consists of Cobra command definitions, a git operations wrapper (mix of `go-git` and direct exec), and a state-machine sequencer for multi-step rebase operations with conflict handling. The architecture is modular with clear separation between git operations, GitHub API, state management, and user interface, making it a solid example of a domain-specific developer tool.