Merlion is a mature Python library for time series intelligence, specializing in anomaly detection and forecasting. It provides a comprehensive, modular ecosystem including model zoo (classical, tree-based, deep learning, ensemble, AutoML), composable transforms, post-processing chains, evaluation frameworks, and a Dash-based interactive dashboard. The architecture follows a clean layered design: data loading via `ts_datasets`, core `TimeSeries` abstraction, `ModelBase` hierarchy with config-driven instantiation, invertible transforms, and pluggable post-rules. It integrates with Spark for distributed inference and provides benchmarks against standard datasets (NAB, M4, UCR). Though primarily a library (application), it includes research-oriented components such as state-of-the-art transformer architectures (Autoformer, Informer) and Bayesian change point detection, making it a hybrid tool suitable for both production and research.
This repository is an Apache Cordova plugin that provides a cross-platform API for capturing photos and selecting images from the device's image library. It supports Android, iOS, and browser platforms. The plugin exposes a `navigator.camera` object with methods `getPicture`, `stop`, and `cleanup`. The JavaScript front-end validates arguments and delegates to native code via Cordova's plugin system. Native implementations handle camera launch, image capture, scaling, cropping, orientation correction, EXIF data preservation, and saving to photo album. The Android implementation uses Android intents and content providers, while the iOS implementation uses UIImagePickerController (and PHPickerViewController on iOS 14+). The browser implementation uses HTML5 video and canvas for capture. The codebase is well-structured with clear separation of concerns across platforms. Notable components include a sophisticated JPEG EXIF header writer for iOS and reusable UIImage extension methods for image scaling and orientation correction. The plugin is actively maintained with recent releases and comprehensive CI testing across multiple Android and iOS versions.
Trussed is a no_std Rust library and framework for building cryptographic firmware on microcontrollers. It implements a client-service syscall architecture: applications use strongly-typed client traits such as CryptoClient, FilesystemClient, and CertificateClient to send Request enums through an interchange channel; Service::process dispatches requests to pluggable mechanism implementations or custom backends, persists keys and files across three littlefs2 filesystems (internal, external, volatile), and returns Reply enums. It is not a standalone application or CLI but an embedded component used by firmware runners such as Solo 2 and Nitrokey 3.
The rstatix package provides a simple and intuitive pipe-friendly framework for performing basic statistical tests and data analysis. It includes functions for t-tests, ANOVA, Wilcoxon tests, correlation tests, and more. The package is designed to be easy to use and integrates with the tidyverse design philosophy.
Bolt CEP is a comprehensive boilerplate for building Adobe Common Extensibility Platform (CEP) extensions using modern web technologies. It provides a unified development experience for creating extensions that work across Adobe applications like Photoshop, Illustrator, Premiere Pro, and After Effects. The system features a monorepo structure containing the core boilerplate, a project creation CLI (create-bolt-cep), and a specialized Vite plugin (vite-cep-plugin) that handles CEP-specific build tasks. Developers can choose between React, Vue, or Svelte for their frontend framework while writing type-safe ExtendScript that compiles down to ES3 for CEP compatibility. Key innovations include an end-to-end type-safe bridge between CEP JavaScript and ExtendScript (via evalTS/listenTS/dispatchTS), automated ZXP packaging with cross-platform signing support, and intelligent asset handling. The build process leverages Vite for fast HMR during development and Rollup for producing CEP-compatible ExtendScript bundles.
MD-TUI is a Rust-based terminal markdown viewer (TUI) that renders `.md` files with full keyboard navigation, syntax highlighting via tree-sitter, inline images, foldable `<details>` blocks, mermaid diagrams, table rendering, search, and link following (internal/external/wiki). It can be used as a standalone binary (`mdt`) or as a library. The architecture is monolithic but modular: a custom PEG parser (`src/md.pest`) converts markdown into a component tree (`ComponentRoot`) composed of `TextComponent` and `ImageComponent` nodes; these are rendered to the terminal using `ratatui`. Configuration is loaded from `~/.config/mdt/config.toml` or environment variables. The repository demonstrates strong Rust craftsmanship with well-separated modules, optional feature flags (`tree-sitter`, `network`), thread-local caching for syntax highlighting, and a comprehensive test suite covering parsing edge cases, search, and rendering behavior.
pymupdf4llm is a Python library for converting PDF documents into Markdown, JSON, text, or structured chunks optimized for LLM/RAG ingestion. It is the official PDF-to-Markdown converter for the PyMuPDF ecosystem, delivered as part of the pymupdf package. The system provides two parallel conversion paths: a legacy mode (pymupdf_rag.py) and a layout-aware mode (document_layout.py) that uses a GNN-based page segmentation model (PyMuPDF-Layout) for improved table, header, and list detection. A dedicated chunking subsystem (src/helpers/chunking/) splits documents into retrieval-friendly pieces using layout signals (bounding boxes, font sizes, gaps) without semantic embeddings, and supports export to LangChain Document and LlamaIndex Node objects. OCR support is integrated via multiple backends (Tesseract, RapidOCR, PaddleOCR) with an ONNX-based decision model that classifies pages to determine if OCR is needed. The library also includes a batch converter with automatic worker sizing, a Gradio-based GUI example, and a LlamaIndex reader integration. External dependencies include pymupdf, optional pymupdf-layout for layout mode, tiktoken for token counting, and optional OCR engines. The codebase is modular with clear separation of concerns, comprehensive tests, and active maintenance, though it carries some technical debt from dual code paths and a custom build backend.
Gavel is a Flask-based web application designed for ranking projects at events like hackathons using pairwise comparisons. The system presents judges with pairs of projects to compare, updating rankings in real-time via a Bayesian inference algorithm. Key components include a custom SQLAlchemy class for serializable transaction isolation, a standalone ranking algorithm module (crowd_bt.py), and utility functions for data handling and security. The application uses PostgreSQL for data storage, Celery for asynchronous email tasks, and relies on Redis as a message broker. Admin interfaces allow managing projects, judges, and global settings, with real-time updates to project rankings displayed via the Mu parameter.
Nostalgist.js is a JavaScript library that provides a high-level API for running retro console emulators (NES, SNES, Game Boy, Sega Genesis, etc.) directly within web browsers. It wraps RetroArch compiled to WebAssembly via Emscripten, handling the complex setup of virtual file systems, core loading, ROM resolution, and configuration. The library exposes a clean facade (`Nostalgist`) with static methods like `launch`, `nes`, `snes` for quick starts, and instance methods for save/load states, screenshots, button presses, cheat management, and low-level Emscripten access. It supports caching, shaders, multi-disc games, and custom resolvers for cores, ROMs, and BIOS files, making it a versatile tool for embedding retro gaming into web applications. The architecture is modular: `Nostalgist` orchestrates the launch process, `EmulatorOptions` resolves and caches all file inputs (cores, ROMs, BIOS, states, cheats), `Emulator` manages the Emscripten runtime and RetroArch communication, and `EmulatorFileSystem` abstracts the virtual file system. The `ResolvableFile` class handles diverse input types (URLs, Blobs, Responses, etc.) uniformly. The library is well-tested with both integration and end-to-end tests, follows semantic versioning, and has active maintenance with frequent releases.
GoTrue is a self-contained user registration and authentication API written in Go. It provides endpoints for signup, login (via email/password or OAuth2 providers like GitHub, GitLab, Google, Bitbucket, Facebook), token refresh, password recovery, email verification, and user management (CRUD for admin users). The architecture is a monolithic HTTP API using the chi router, backed by a MySQL database (via pop/v5 ORM) and a configurable mailer (SMTP or noop). It supports both single-tenant and multi-tenant deployments, with JWT-based authentication (HS256) and optional SAML SSO. The codebase is well-organized into packages: api for HTTP handlers, models for database entities, conf for configuration, mailer for email sending, and crypto for security utilities. It includes extensive unit tests and integration tests using a MySQL test database.
Termux is an Android terminal emulator and Linux environment app that provides a full command-line experience on Android devices. It combines a VT100/xterm-compatible terminal emulator (written in Java with JNI for PTY creation) with a bootstrap Linux environment containing common command-line tools (bash, ssh, compilers, etc.). The architecture is modular: a core terminal-emulator library handles escape sequences, Unicode, sixel graphics, and session management; a terminal-view module provides the Android View widget for rendering; a termux-shared library contains reusable utilities for file I/O, IPC, preferences, error handling, and shell execution; and the app module ties everything together with activities, services, and a plugin ecosystem (API, Float, Tasker, Widget, etc.). Key entry points include TermuxActivity (main UI), TermuxService (foreground service managing sessions), RunCommandService (plugin command execution), and TermuxInstaller (bootstrap setup). External dependencies include Android SDK (target 28, compile 36), Gradle, NDK for native code, and libraries like Apache Commons IO, Guava, and Markwon for markdown rendering.
autocannon is a high-performance HTTP/1.1 benchmarking tool written in Node.js, inspired by wrk and wrk2. It operates as both a CLI tool and a programmable library. The architecture is centered around a run loop that manages multiple concurrent HTTP clients, each capable of pipelining requests. Key components include a request builder that constructs raw HTTP request buffers, a pipelined request queue for handling out-of-order responses, and a histogram-based statistics engine using hdr-histogram-js with WebAssembly for efficient percentile calculations. The tool supports HTTPS, Unix sockets, multipart forms, HAR file replay, worker threads for parallel execution, rate limiting with coordinated omission correction, and extensive customization via setup functions and event hooks. The codebase is well-structured with clear separation of concerns, comprehensive test coverage, and active maintenance.
zlFetch is a lightweight JavaScript library that wraps the native Fetch API with quality-of-life improvements. It automatically parses response bodies based on `Content-Type` (JSON, text, form-urlencoded, NDJSON, Blob), provides promise-based error handling that rejects on 4xx/5xx status codes, supports request aborting, and includes shorthand methods for GET, POST, PUT, PATCH, DELETE. The library also offers streaming capabilities (SSE, NDJSON, chunked transfer), an EventSource wrapper for server-sent events, query string helpers, authorization header helpers, and a `createZlFetch` factory for pre-configured instances. The code is modular, well-typed with JSDoc, and thoroughly tested across browser and Node.js environments using vitest.
picosnitch is a Linux daemon for per-executable network bandwidth monitoring using eBPF (CO-RE) and fanotify. It tracks which executables make network connections, records bytes sent/received, timestamps, and metadata (SHA256 hashes, optional VirusTotal and GeoIP lookups). The system provides real-time and historical views via multiple interfaces: a curses TUI (both live top and historical browser), a web UI, and a UNIX socket live feed. The daemon uses a multiprocess architecture with privilege-separated subprocesses for monitoring, event processing, database writes, notifications, and external API queries. It supports local SQLite storage and optional remote SQL (MariaDB/MySQL/PostgreSQL) for tamper-evident logging. The repository also includes a comprehensive comparative benchmark suite (bench/) that tests picosnitch against nine other network monitors across 24 scenarios, with a reusable ToolAdapter framework for running controlled experiments.
This repository implements a Build Server Protocol (BSP) server that integrates Xcode builds with language servers like sourcekit-lsp. It parses Xcode build logs (either from IDE builds or xcodebuild) to extract compiler flags and serves them via BSP to provide accurate code completion, navigation, and other language features for Swift, C, C++, Objective-C, and Objective-C++ projects. The server operates in two modes: 'xcode' mode automatically monitors build logs via a post-build script or file watching, and 'manual' mode processes build logs on demand. Key components include a robust compilation database handler, a parser for Xcode's proprietary xcactivitylog binary format, and a log parser that handles various Xcode build output formats. The project is actively maintained with recent commits and shows no significant technical debt.
This repository is a VS Code extension that provides an enhanced Markdown preview and editing experience. It supports live preview with scroll sync, math rendering (KaTeX/MathJax), diagrams (Mermaid, PlantUML, D2, etc.), wikilinks, backlinks, graph view, AI translation, code chunk execution, and export to HTML, PDF, and other formats via Pandoc. All rendering is performed locally for privacy, with optional opt-in remote services for PlantUML and image uploading. The architecture is a monolithic VS Code extension with two activation paths: desktop (`src/extension.ts`) and web (`src/extension-web.ts`), sharing common logic in `src/extension-common.ts`. Core rendering is delegated to the `crossnote` library, while the extension provides VS Code integration including preview panels, custom editor, commands, configuration, file watchers, and language features (completion, hover, navigation). The build system uses esbuild and gulp to produce multiple output targets. Key entry points include `src/preview-provider.ts` for preview lifecycle management, `src/notebooks-manager.ts` for workspace note indexing and backlinks, and `src/config.ts` for bridging VS Code settings with crossnote configuration. External dependencies include `crossnote` (rendering engine), `@earendil-works/pi-ai` (AI translation providers), and optional binaries like Pandoc, PlantUML, D2, and Chrome/Puppeteer for export. Data flows center on file changes triggering re-rendering via crossnote, with wikilinks resolved through a note index. AI translation operates incrementally: blocks are split, sent to an LLM API, cached on disk, and streamed into the preview. The extension is highly configurable with over 80 settings and supports localization in 10 languages.
LinkSheet is an Android application that restores a modern, privacy-oriented URL chooser: it intercepts http/https and related intents, runs the URL through a configurable resolution pipeline, and presents a bottom sheet where users pick an app, browser, or action such as copying or downloading. The core pipeline is implemented in the engine feature module as a series of steps and rules: ClearURLs parameter stripping, embed resolution, FastForward link shortening, LibRedirect frontend substitution, AMP-to-HTML conversion, redirect following, download detection, and preview generation. It also supports user-defined scenarios and expression rules, Shizuku elevation for domain-verification tasks, profile switching, backup/restore, remote configuration, and opt-in Aptabase analytics.
The stripe/java repository is the official Java client library for the Stripe API, providing type-safe access to Stripe's payment processing and financial services. It features a layered architecture with model classes representing Stripe objects, service classes for API resource access, parameter builders for request configuration, and webhook handling infrastructure. The library supports both legacy static API patterns and a modern instance-based StripeClient entry point, with comprehensive telemetry, expandable fields, and extra parameters for accessing beta features. Code generation from OpenAPI specs ensures consistency with Stripe's API evolution, while hand-crafted components like utility classes and webhook verification demonstrate engineering excellence.
This repository is a comprehensive C# library (Ical.Net) for parsing, manipulating, serializing, and evaluating iCalendar (RFC 5545) data. It is a library, not a standalone application, designed to be embedded in calendar and scheduling software. The architecture is centered around a rich domain model (Calendar, CalendarEvent, Todo, Journal, Alarm, VTimeZone) built on top of core data types (CalDateTime, Duration, Period, RecurrenceRule). It features a dual serialization path (a newer CalendarSerializer and an older SimpleDeserializer) and a powerful recurrence rule evaluation engine that handles complex RRULE, RDATE, and EXDATE combinations. Key strengths include its robust timezone handling via NodaTime, a well-designed collection framework (GroupedList, MultiLinkedList), and a pluggable converter system for custom properties. The codebase is heavily tested with hundreds of .ics fixtures and benchmarks, indicating a focus on correctness and performance. While it carries some technical debt from its long history (deprecated APIs, dual serializers), it remains a high-quality, actively maintained implementation of the iCalendar standard.
Coz is a causal profiler for native code (C/C++, Rust, Go, Swift, Java) that uses virtual speedup experiments to identify which lines of code, if optimized, would most improve program throughput or latency. It operates by injecting a shared library (libcoz) via LD_PRELOAD or DYLD_INSERT_LIBRARIES, interposing synchronization primitives to track blocking and apply controlled delays on non-selected threads. The profiler outputs a JSON Lines profile that can be visualized with a built-in web viewer (D3.js scatter plots with loess smoothing) or analyzed via CLI. It includes an AI-assisted feature for suggesting progress point placement and optimization advice. The architecture is a hybrid: a core runtime library in C++ with language bindings for Rust, Go, Swift, and Java (JVMTI agent), plus a Python CLI that orchestrates profiling, visualization, and LLM integration. The project is a research artifact from UMass Amherst, published at SOSP 2015, and remains actively developed with modern features like streaming AI support.