Chisel is a collection of LLDB commands for debugging iOS and macOS applications. It provides a rich set of commands to inspect and manipulate the UI hierarchy, view controllers, accessibility, auto layout, animations, and memory. The project consists of Python scripts that define LLDB commands using a custom base class (FBCommand) and a native C/Objective-C framework (Chisel.framework) that enables heap scanning for Objective-C instances. The Python layer evaluates Objective-C expressions in the debugged process, while the native framework uses malloc zone enumeration to find live objects. The architecture is a plugin for LLDB, with commands loaded dynamically from a directory. Key entry points are the LLDB commands themselves (e.g., pviews, pvc, visualize, border, findinstances). External dependencies include LLDB, the iOS/OS X runtime, UIKit, CoreAnimation, and Foundation. The codebase is well-structured but shows some technical drift (Python 2 usage, deprecated imp module, old Xcode project settings).
This repository provides the Bazel build rules and tooling for building Android applications (APKs, AABs, libraries) using Bazel. It includes Starlark rules for android_binary, android_library, android_local_test, etc., along with a suite of Go and Java tools for resource processing, dexing, R8 optimization, manifest merging, and mobile-install deployment. The codebase is production-grade, used internally at Google, and supports both WORKSPACE and Bzlmod. It features a well-architected processing pipeline pattern, a reusable flag system, and extensive test infrastructure. The repository is actively maintained with regular commits and CI, though it carries some technical debt from internal migration and legacy feature flags.
Min is a production desktop web browser built on Electron, focused on speed, minimal UI, and privacy. The repository contains the complete application: main-process window and view management, tab/task state, a plugin-driven search/address bar, session restore, download handling, reader mode, PDF viewing, content blocking, translation, and password-manager integrations. The dominant architecture is an Electron main/renderer split with IPC-driven communication, several hidden service pages (places, translation), and a custom module bundling pipeline for main, browser, and preload scripts. Although it embeds data-oriented components such as a history full-text search engine and a bookmark tag index, this is an application, not a data/research project; those components serve browser features rather than analytical workflows. The primary entry points are `main/main.js` for the Electron main process, `js/default.js` for browser UI initialization, and `index.html` for the renderer shell. Core data flows are local: browsing history and bookmarks are persisted through Dexie/IndexedDB in a hidden places service, full-text history search uses a custom BM25-style ranking implementation, and network requests are filtered by a modified ABP filter parser. External dependencies include Electron, Dexie, pdfjs-dist, Readability, drag-and-drop libraries, external CLI password managers, EasyList-style filter lists, the Public Suffix List, and Bergamot translation models. The searchbar plugin system and password-manager abstraction are the most notable architectural patterns. The codebase is actively maintained but shows medium technical drift: it relies on a custom concatenation-based build instead of a standard bundler, mixes legacy callbacks with modern async/await, vendors modified forks of third-party code, and contains Electron-version-specific workarounds. No automated test suite is present in the repository, and some platform-specific code is fragile across Electron upgrades. Overall it is a solid, working desktop application with several clean abstractions and a small number of genuinely reusable components, but it would benefit from test coverage and modernization.
This repository is a Next.js static site that serves as the companion website for the 'Complete Intro to Web Dev v3' course by Brian Holt. It renders lesson content from Markdown files, provides interactive code editors via Klipse, and includes navigation between lessons. The architecture is a standard Next.js application with static generation at build time. The codebase is well-organized with clear separation of concerns: data loading logic in `data/lesson.js`, layout components in `components/`, and page routing in `pages/`. While the site is tailored to this specific course, the lesson loading module is a reusable pattern that could be extracted for other course sites. The project is actively maintained with recent commits and a CI/CD pipeline for deployment to GitHub Pages.
This repository provides reference implementations of common system design patterns in Python and Java. It is primarily an educational resource containing standalone algorithm implementations for consistent hashing, rate limiting (token bucket, leaky bucket, sliding window variants), and load balancing algorithms (round robin, weighted round robin, least connections, least response time, IP hash). The code serves as a learning tool for system design interviews and concepts rather than a production-ready application. Each implementation is self-contained with usage examples embedded in the source files. The repository has no external dependencies beyond standard libraries, making it easy to extract and study individual patterns.
boring.notch is a native macOS utility that replaces the system menu bar and notch area with a customizable, expandable control center. Built with SwiftUI and AppKit, it runs as a background LSUIElement app and presents a notch-shaped window that reacts to hover, click, and drag gestures. In production it provides music playback control with a spectrum visualizer, calendar and reminders integration, a drag-and-drop file shelf with Quick Look and sharing, replacement system HUDs for volume/brightness/keyboard backlight, a webcam mirror, battery status, and download/notification indicators. Media playback is supported across Apple Music, Spotify, YouTube Music, and a legacy NowPlaying path, with a private MediaRemote adapter binary used to access now-playing metadata and remote commands.
JARVIS2 is a real-time dashboard framework designed for Raspberry Pi, built with Flask (Python) and Mithril (JavaScript). It features live-updating widgets via server-sent events (SSE) and a plugin-based job system for data fetching. The backend schedules periodic jobs (e.g., weather, public transport, email, RSS) that push data to connected browsers. The frontend renders widgets using Mithril components and updates them reactively as events arrive. The architecture is a monolith: a single Flask application with background scheduling via APScheduler. Key entry points are the Flask routes for dashboards, individual widgets, and the SSE event stream. External dependencies include various APIs (Yr, Entur, Avinor, Google APIs, Sonos, etc.) and libraries (Flask, APScheduler, requests, BeautifulSoup, soco). The codebase is well-structured, with clear separation between job implementations, static assets, and templates. It includes a comprehensive test suite and CI pipeline. The project is actively maintained, targeting Python 3.14 and using modern tooling (uv, ruff). However, it retains some deprecated dependencies (oauth2client) and Python 2 compatibility shims, indicating moderate technical drift.
OpenYurt is an open-source platform that extends Kubernetes for edge computing and IoT scenarios. It provides a set of components to manage edge nodes, IoT devices, and network connectivity across cloud and edge environments. The architecture includes multiple binaries: yurt-manager (control-plane controllers and webhooks), yurthub (edge node proxy/cache), yurtadm (admin CLI for node lifecycle), yurt-iot-dock (IoT device bridge to EdgeX Foundry), yurt-tunnel-server/agent (secure tunneling, being replaced by Raven), and node-servant (node conversion). The system uses custom Kubernetes CRDs (NodePool, YurtAppSet, Gateway, PlatformAdmin, etc.) and controller-runtime patterns for reconciliation. Key data flows involve edge nodes connecting to the cloud via yurthub, which proxies and caches Kubernetes API requests, filters responses, and provides offline autonomy. The system integrates with EdgeX Foundry for IoT device management and uses Helm charts for deployment. External dependencies include Kubernetes, EdgeX Foundry, and various Go libraries. The codebase demonstrates a modular controller architecture with reusable patterns such as filter chains, health checkers, certificate management, and load balancing strategies.
Cambio is a React component library that simplifies shared-element animations for dialogs/popups. It provides a compound component API (`Cambio.Root`, `Trigger`, `Portal`, `Backdrop`, `Popup`, `Title`, `Description`, `Close`) built on top of Base UI's accessible Dialog primitives and Motion's animation engine. The library offers four built-in motion presets (snappy, smooth, bouncy, reduced) configurable globally, per-component via variants, or overridden individually. It supports dismissible popups driven by drag gestures with configurable threshold and velocity, automatic respect for `prefers-reduced-motion`, and explicit reduce-motion overrides. The architecture uses React Context for state propagation and Motion's `motion.create` to wrap Base UI components. The code is well-typed in TypeScript, organized into clear modules, and demonstrates craftsmanship in its motion configuration resolution chain and drag physics handling. The repository also includes a documentation website built with Next.js and Fumadocs.
This repository is a full-stack web application that syncs WhatsApp profile pictures into Google Contacts. A user authorizes WhatsApp Web by scanning a QR code (whatsapp-web.js + Puppeteer/Chromium) and authorizes Google via OAuth2 against the People API. The backend then lists Google contacts, loads WhatsApp contacts, matches them by phone number, downloads the WhatsApp profile picture, rate-limits writes to 1 per 1.5 seconds, and updates contact photos through the People API. It also includes an optional Buy Me a Coffee purchase gate: paid emails are checked against Buy Me a Coffee's API and bound to a WhatsApp account ID in Redis for 31 days.
pdf-to-printer is a small, focused Node.js/Electron library that prints PDFs and images to Windows printers by shelling out to a bundled SumatraPDF executable. The public API exposes three async functions: `print()`, `getPrinters()`, and `getDefaultPrinter()`. `print()` validates the target file, builds SumatraPDF command-line arguments from a typed options object (printer, pages, orientation, paper size, duplex, copies, etc.), and executes the binary via `child_process.execFile`. Printer discovery uses PowerShell's `Get-CimInstance Win32_Printer` and parses the formatted text output into structured `Printer` objects with device ID, name, and supported paper sizes. The code is TypeScript with strict mode, unit-tested with Jest, and bundled with webpack for UMD distribution. It is Windows-only by design and throws on other operating systems.
This repository is a Hardhat-based template for developing Solidity smart contracts. It provides a pre-configured development environment with sensible defaults for compilation, testing, linting, and deployment. The core functionality is demonstrated through a simple `Lock` contract that implements a time-locked withdrawal mechanism, complete with custom errors, events, and comprehensive tests. The template integrates TypeChain for TypeScript bindings, Ethers.js for Ethereum interactions, and various tooling like Solhint, Prettier, and Solcover. It is not a production application but a starting point for new Solidity projects, emphasizing best practices and developer experience.
The repository provides the official PyTorch implementation of DoRA (Weight-Decomposed Low-Rank Adaptation), a parameter-efficient fine-tuning method. It integrates with Hugging Face PEFT and includes training/evaluation scripts for vision-language and language tasks (e.g., VQA, ScienceQA, commonsense reasoning). The architecture is modular, with core components like DoRA tuners, adapter controllers, and low-rank layers. Entry points include training scripts (finetune.py, train_dora.py), evaluation scripts (evaluate.py, run_llava.py), and serving tools (gradio_web_server.py). External dependencies include PyTorch, Transformers, PEFT, bitsandbytes, and dataset-specific libraries.
Signale is a highly configurable logging library for Node.js. It provides 19 out-of-the-box loggers (e.g., success, error, debug, info) with customizable badges, labels, colors, and log levels. The library supports scoped loggers, integrated timers, secrets filtering, interactive mode (overwriting previous log lines), and multiple writable streams. Configuration can be set globally via package.json or locally per instance. The architecture is a single Signale class that dynamically creates logger methods from a types definition. The main entry point (index.js) exports a default instance and the Signale constructor. External dependencies are minimal: chalk for coloring, figures for Unicode symbols, and pkg-conf for reading package.json configuration. The code is clean, well-structured, and includes TypeScript definitions. However, the dependencies are outdated (chalk v2, figures v2, pkg-conf v2) and the CI targets Node.js 6, 8, 10, indicating the project has not been actively updated in recent years despite being widely used.
NaïveProxy is a censorship circumvention proxy that repurposes Chromium's network stack to mimic genuine Chrome HTTPS traffic at the TLS, HTTP/2, and QUIC protocol levels. The repository is a heavily trimmed Chromium source tree with custom patches for traffic padding, SOCKS5 client support, and a padding layer between proxy endpoints. It produces a statically linked `naive` binary (client and server) and an Android APK plugin (SagerNet). The architecture is a monolithic executable that bundles Chromium's networking libraries (BoringSSL, HTTP/2, QUIC) with a thin custom layer for configuration parsing and protocol padding. Key entry points are the `naive` binary (via command-line and config.json) and the Android plugin service. External dependencies include the Chromium source base (fetched at build time), BoringSSL, and system libs. The custom components (padding framer, config parser) are small, well-tested, and can be extracted for reuse in other proxy or traffic analysis projects.
Cali is a TypeScript-based CLI application designed for React Native and Expo development teams. It functions as an AI-powered orchestration layer that automates mobile quality assurance, code review, and performance analysis. The system operates by ingesting repository context (PR data, mobile artifacts) and executing structured agent loops that interact with platform-specific tools (Android/iOS SDKs) via the Vercel AI SDK. It supports both local execution and CI environments (GitHub Actions, EAS), generating structured reports in JSON and Markdown formats. Architecturally, it follows a monorepo pattern with distinct packages for the core CLI (packages/cali) and platform-specific tool wrappers (packages/tools). The core logic relies on a role-based command structure where specific tasks (QA, Review, Dev) are delegated to specialized agent roles. Data flow is deterministic, moving from context resolution through tool execution to report publishing, ensuring consistent behavior across different environments. The tool distinguishes itself by managing complex mobile development contexts, such as artifact parsing (APK/IPA) and device management, which are typically brittle in automated workflows. It integrates skill discovery for AI agents and supports multiple output publishers (local file, Vercel Blob). While it solves a specific niche problem effectively, it introduces dependencies on external binaries and rapid-versioning AI SDKs that require careful maintenance.
TorchFort is a library that bridges PyTorch with Fortran and C/C++ programs, primarily targeting HPC/scientific computing applications. It provides a C API that allows users to load PyTorch models (via TorchScript or built-in MLP), train them, and perform inference directly on user-provided arrays without data copying. The library supports supervised learning as well as reinforcement learning (RL) with several state-of-the-art algorithms: DDPG, TD3, SAC, and PPO. It includes comprehensive RL infrastructure such as replay buffers, rollout buffers, online running normalizers, and distributed training via MPI. Integration with Weights & Biases is available for experiment tracking. Architecturally, TorchFort consists of a thin C API layer, a set of C++ implementations using LibTorch, and Fortran bindings generated via ISO_C_BINDING. The core C++ code is organized into modules for model management, training, distributed communication, CUDA utilities, and RL subsystems. Configuration is externalized via YAML files, and the library is designed to be used as a static or shared library linked into user applications. Notable components include a prioritized replay buffer with sum-tree implementation (replay_buffer.h), an online running normalizer using Welford's algorithm with MPI synchronization (running_normalizer.h), and a tensor list abstraction for handling multiple typed arrays (tensor_list.h). The codebase demonstrates good engineering practices with extensive test coverage, error handling via return codes, and support for both CPU and GPU execution. While primarily an application/library for integrating PyTorch into HPC codes, the repository also contains research-quality RL algorithm implementations and data preprocessing components, giving it a hybrid character.
PyRanges (version 0, legacy) is a Python library for genomic interval operations, analogous to Bioconductor's GenomicRanges. It provides a comprehensive set of tools for manipulating, comparing, and analyzing genomic intervals and annotations. The library supports reading and writing common bioinformatics file formats (BED, GTF, GFF3, BAM, BigWig), and implements a wide range of operations including merging, intersection, subtraction, join, nearest neighbor, clustering, coverage, and statistical methods like Jaccard and Fisher exact. Internally, PyRanges represents intervals as a dictionary of pandas DataFrames keyed by chromosome and optionally strand. This design enables efficient per-chromosome parallelism and easy integration with the Python data science stack. Operations are implemented as modular functions in separate files under the `methods/` directory, each accepting a DataFrame and keyword arguments from a central dispatcher. The library also provides a parallel execution framework using Ray via `pyrange_apply` and related functions, allowing users to apply custom functions to each chromosome/strand group in parallel. Although primarily a software library, this repository has a strong research character: it includes built-in example datasets (e.g., ChIP-seq peaks, CpG islands, Ensembl annotations), a bookdown tutorial with executable R Markdown, property-based tests that compare results against the bedtools suite, and statistical methods designed for colocalization and annotation enrichment. This makes it equally valuable as a research tool for bioinformatics analysis. Maintenance note: This is the legacy version 0 of PyRanges, superseded by a redesigned version 1 (pyranges1). Despite the deprecation, the codebase is mature, well-tested, and still functional. The design patterns (modular operations, per-chromosome dispatch, property-based testing against a reference tool) are noteworthy and could be reused in other bioinformatics and data engineering projects.
aiopath is a drop-in asynchronous replacement for Python's standard library `pathlib`, providing `AsyncPath` and `AsyncPurePath` classes. It replicates the complete `pathlib` API but makes all I/O-bound methods (like `.exists()`, `.read_text()`, `.glob()`, `.mkdir()`) awaitable, allowing non-blocking filesystem operations in asyncio or trio applications. The library builds on `anyio.to_thread` for executing blocking OS calls off the event loop and `aiofile` for async file handles. It strictly inherits from `pathlib.Path` and `PurePath`, preserving method signatures, docstrings (via a metadata decorator), and class hierarchy. The implementation is clean and type-annotated throughout, requiring Python 3.12+ and using modern syntax like `type` aliases. Old compatibility layers (for Python 3.9-) are kept in `src/aiopath/old/` alongside stale backup files, indicating an ongoing renovation to drop legacy support.
This repository is a large, actively maintained collection of ~1,000 standalone C++ solutions to LeetCode and similar interview algorithm problems, published by the 'codestorywithMIK' YouTube educator. It is organized into ~30 topic folders (Arrays, DP, Graph, Tree, Sliding Window, Segment Tree, Trie, strings, etc.) with per-topic READMEs, difficulty subfolders, and an extensive set of iPad PDF lecture notes accompanying YouTube videos. It is neither a deployable application nor a data/research project: it is a reference/educational code library whose primary consumption path is copying a solution into LeetCode's online judge or studying the annotated approaches. As such it is classified as 'application' only in the loose sense that it consists entirely of source code rather than data artifacts; in practice it is a non-executable solution bank, and this hybrid nature should be understood by anyone evaluating it for reuse.