Java Mission Control (JMC) is an open-source tool for monitoring, managing, and profiling Java applications. It provides a graphical user interface built on Eclipse RCP for connecting to Java applications via JMX, analyzing Java Flight Recorder (JFR) data, and performing heap analysis. The application features a modular OSGi plugin architecture with core libraries for shared functionality (unit handling, flight recorder parsing, JMX common) and application plugins for specific features (flight recorder UI, JMX console, browser, agent). Key capabilities include real-time MBean monitoring, flight recording control and analysis, heap dump analysis, and custom rule-based diagnostics.
This repository provides a PHP/Hack library for creating, managing, and deleting temporary directories. The core class `TemporaryDirectory` offers a fluent API to configure directory name, location, permissions, and force creation. It generates unique directory names using timestamps and random numbers, and supports recursive deletion with proper handling of broken symlinks and garbage collection to avoid filesystem locks. The library also includes a destructor-based cleanup mechanism for automatic deletion when the object goes out of scope. The architecture is a single, self-contained class with two custom exception classes for invalid directory names and path conflicts. It relies only on the system's temporary directory and standard filesystem operations, making it lightweight and portable. The code demonstrates attention to edge cases such as trailing slashes, existing directories, and cross-platform path handling. While the syntax is Hack (a PHP dialect with type annotations), the logic is straightforward and could be adapted to other languages. The library is well-tested with PHPUnit and follows semantic versioning with an active changelog.
This is a full-stack web application for managing a WireGuard VPN server, implemented with Nuxt 4 (Vue 3 frontend) and Nitro (backend) with a SQLite database via Drizzle ORM. It provides a web-based admin UI for configuring the WireGuard interface (MTU, port, device, CIDR, routing table), managing clients (create, enable/disable, set expiry, per-client firewall rules, custom DNS/MTU), viewing traffic charts, and monitoring client status. The application supports multi-user authentication with password login, TOTP two-factor authentication, and OAuth providers (Google, GitHub, generic OIDC). It also includes an experimental AmneziaWG obfuscation mode, Prometheus and JSON metrics endpoints, a CLI for administrative tasks (password reset, client listing, QR code generation), and integration with iptables/nftables for per-client firewall rules. The system is packaged as a Docker image and relies on the host kernel's WireGuard module and iptables tooling.
HyprQuickFrame is a native screenshot utility for Hyprland built using the Quickshell framework. It provides an overlay-based UI for capturing screenshots in region, window, or full-screen modes, with options to edit, save to disk, copy to clipboard, or share via KDE Connect. The application features shader-based dimming, animated transitions, and dynamic theme synchronization with wallpapers via Noctalia. The architecture centers around a QML application shell that manages state and delegates to specialized UI components (RegionSelector, WindowSelector, ControlBar, etc.). Screenshot capture is performed by spawning external processes (grim, wl-clipboard, editors) based on the selected mode. The theme system allows users to customize colors and animations via a TOML file, with a Python script available to sync colors from Noctalia-generated palettes. Key reusable components include a custom animated toggle button (QuickToggle.qml), a segmented control bar (ControlBar.qml), a TOML-based theme parser (Theme.qml), and a Noctalia theme synchronization script (sync_theme.py). These components are designed with minimal dependencies and demonstrate advanced QML animation techniques and configuration patterns.
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.
OpenCTI is an open-source cyber threat intelligence platform that ingests, manages, and analyzes threat data using the STIX 2.0/2.1 standard. The system is a monorepo containing a Node.js/TypeScript GraphQL backend (opencti-graphql), a React/Relay frontend (opencti-front), a Python client library (client-python), and a Python worker service (opencti-worker). The backend uses Elasticsearch/OpenSearch as its primary data store, Redis for caching and pub/sub, RabbitMQ for connector queues, and PostgreSQL for migrations. The frontend provides full CRUD UIs, dashboards, workspaces, playbook automation, and workflow management. Key entry points include the GraphQL API (resolvers per entity type), the frontend React app with Relay data fetching, and the Python client for programmatic access. Data flows involve ingestion via CSV/JSON/TAXII/RSS feeds, manual creation, connector enrichment, and inference rules that automatically derive relationships. External dependencies include Elasticsearch, Redis, RabbitMQ, MinIO/S3 for file storage, and optional AI services. The platform supports enterprise features (playbooks, PIR, XTM Hub) gated by license checks.
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 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.
vue-cesium is a comprehensive Vue 3 component library that wraps CesiumJS, enabling developers to build 3D geospatial web applications using declarative Vue components. It provides a rich set of components for the Cesium viewer, imagery layers, terrain providers, entities, primitives, geometries, graphics, controls (compass, zoom, navigation, status bar, print), overlays (HTML, heatmap, ECharts, wind, dynamic, typhoon), drawing/measurement tools, analysis features (viewshed, flood), post-process effects, and a full UI kit (buttons, icons, tooltips, sliders, spinners, fab). The library follows a composable-based architecture where each Cesium object type has a corresponding composable managing its lifecycle, prop reactivity, and event bridging. It supports multiple map providers (Baidu, Tianditu, ArcGIS, etc.) with custom coordinate transformations for Chinese coordinate systems. The project is a monorepo with packages for components, composables, shared utilities, locale, theme, and directives. It includes a comprehensive documentation site built with Vitepress featuring live demos and bilingual support (en-US, zh-CN). The codebase demonstrates solid engineering practices with reusable composables, custom material extensions, and a consistent component pattern, though it has some technical debt such as bundled Cesium workers, global Cesium references, and deep watchers that may impact performance with large datasets.
This repository is the Microsoft Desired State Configuration (DSC) v3 platform, a cross-platform (Linux, macOS, Windows) configuration management CLI tool written in Rust. It provides a declarative, idempotent system for managing operating system and application settings through resources (e.g., registry, services, firewall, packages) and configuration documents (JSON/YAML). The architecture is a Rust workspace of ~30 crates including the main `dsc` CLI binary, a core library (`dsc-lib`) with resource discovery and invocation, a JSON schema generation library (`dsc-lib-jsonschema`) with VS Code integration, platform abstraction libraries, and many individual resource executables (each a separate binary). It supports adapters for PowerShell and Windows PowerShell, extensions for discovery and secrets, an MCP server for AI tool integration, and Bicep integration via a gRPC server. The codebase is well-engineered with extensive tests, i18n, and consistent patterns, though its large surface area and Windows-specific code present maintenance challenges.
jira.js is a comprehensive TypeScript SDK for Atlassian Jira REST APIs, covering Cloud, Data Center, Agile, Service Management, Assets, Administration, Teams, User Management, and User Provisioning surfaces. It is designed as a modular library with separate client factories (e.g., createCloudClient, createServerClient, createAgileClient) that provide typed access to hundreds of API endpoints. The architecture is built on a core transport layer that handles authentication (basic, bearer, OAuth 2.0), request/response validation using Zod schemas, error classification, retry logic, and multipart form data. Every API response is validated at runtime, with configurable behavior on schema mismatch (warn, throw, silent) and an optional audit mode to detect API drift. The library is primarily generated from Atlassian's OpenAPI specifications, resulting in a large, consistent codebase with models, parameters, and API functions organized by product domain. Key entry points include the client factories and subpath imports like 'jira.js/cloud' or 'jira.js/agile'. Data flows are straightforward: consumers construct typed request options and call client.sendRequest(), which returns validated response objects. External dependencies are minimal: zod for runtime validation, and the platform's fetch API for HTTP. The library also includes webhook signature verification, OAuth 2.0 (3LO) helpers for both Cloud and Data Center, and a browser-compatible bundle. Notable patterns include the use of apiObject and openEnum helpers to create Zod schemas that are permissive by default but strict under audit, enabling graceful handling of API evolution. The error hierarchy uses branded symbols for reliable type guards across package copies. The test suite includes extensive live integration tests against real Atlassian instances, with resource tracking and entitlement-aware gating. Overall, jira.js is a well-engineered, actively maintained SDK that prioritizes type safety and runtime validation, though its large generated surface introduces some duplication and maintenance overhead.
This is a Rust library (`kdl`) for parsing, manipulating, and serializing the KDL Document Language. It provides a fully round-trip-preserving parser (formatting, whitespace, comments) supporting both KDL v2 and, optionally, v1. The library exposes a rich AST (`KdlDocument`, `KdlNode`, `KdlEntry`, `KdlIdentifier`, `KdlValue`) with builder patterns and formatting configuration. It integrates with `serde` for deserializing/serializing Rust types from/to KDL, using a well-documented mapping convention (e.g., `#args`, `#rest`, property renames via `#@`). Error handling is implemented via `miette` for rich diagnostics. The repository also includes a language server (`kdl-lsp`) based on `tower-lsp` that provides diagnostics for KDL files, though incomplete. Comprehensive compliance tests (hundreds of input/expected KDL files) ensure spec adherence. The architecture is a single library crate with optional serde support, a separate v1 fallback crate, and an LSP tool. The core parser uses `winnow` with error recovery. Dead code from a disabled KQL query engine exists, and serde support is marked experimental, indicating some technical drift. Overall, it's a high-quality, professionally engineered library with excellent test coverage and well-thought-out abstractions.
This repository provides the official browser language detection plugin for i18next. It implements a modular strategy pattern where each detector (cookie, querystring, localStorage, sessionStorage, navigator, htmlTag, path, subdomain, hash) is a self-contained module with a consistent interface. The main `Browser` class orchestrates detection by iterating through a configurable order of detectors, filters out XSS vectors, and optionally converts detected language codes. The code is well-structured, tested, and production-grade; the cookie detector in particular includes a robust RFC-compliant serialization function. Everything is browser-native with no heavy dependencies beyond i18next itself.
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.
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.
MediKeep is a full-stack personal health record (PHR) application built with FastAPI (Python) and React (Mantine UI). It allows users to manage comprehensive medical data including medications, conditions, allergies, immunizations, lab results, vitals, procedures, treatments, symptoms, injuries, encounters, family history, insurance, pharmacies, and practitioners. The system supports multi-user with patient sharing via invitations, SSO authentication (Google, GitHub, OIDC), custom PDF report generation with trend charts, document management integrations (Paperless-ngx, Papra), backup/restore, and internationalization (13 languages). The architecture follows a modular pattern with CRUD base classes, a service layer, domain events, and extensive testing (pytest, Vitest). Deployment is via Docker Compose with PostgreSQL. The codebase demonstrates strong engineering practices with clean abstractions, reusable components, and comprehensive test coverage, though some areas show signs of ongoing migration (JS to TS, adapter components) and debug artifacts remain.
e-virt-table is a high-performance, canvas-based virtual data table library designed for building spreadsheet-like grids in web applications. It renders tens of thousands of rows and columns using a custom canvas drawing engine with virtual scrolling, fixed columns, cell editing, selection, autofill, copy/paste, sorting, filtering, tree data, cell merging, and undo/redo. The library is framework-agnostic (usable in plain JS, Vue 2/3, and React) and is distributed as an npm package with UMD/ESM/CJS formats. Its architecture follows a modular event-driven pattern: a central Context class manages state and communication between subsystems (Selector, Editor, Database, Scroller, History, Validator, FinderBar, etc.), while a Paint module abstracts canvas drawing operations. The configuration surface is extensive (~100 options via CSS variables and a Config object), enabling deep customization of appearance and behavior. The repository also includes a bilingual VitePress documentation site with hundreds of interactive examples, as well as a dev playground and a suite of system-level tests for border rendering and scrollbar modes.
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.
AngryOxide is a WiFi security auditing tool written in Rust that captures WPA handshakes and PMKID by injecting deauth, disassociation, CSA, rogue M2, anonymous reassociation, and PMKID attacks. It operates as a monolithic binary with a real-time TUI (ratatui) and a headless mode, processing raw 802.11 frames via Linux raw sockets. The tool tracks access points and stations, validates EAPOL 4-way handshakes, and outputs hashcat-compatible hashline files (hc22000), pcapng captures with embedded GPS data (Kismet format), and a Kismet SQLite database. It supports GPS geofencing, target/whitelist filtering, rate limiting, and automatic exit on handshake capture. While primarily an application, it includes data-oriented components such as a custom pcap/pcapng parsing library and GPS coordinate encoding, giving it a hybrid character. The codebase is well-structured with background threads for I/O, custom ratatui widgets, and a reusable pcap-file library, though it lacks unit tests for core logic and relies on unsafe raw socket operations.
Operately is an open-source company operating system for coordinating goals, projects, and teams. It provides a full collaboration suite including spaces (groups), goals with OKRs, project management with milestones and tasks, check-in cadence, retrospectives, discussions, document and file management (Resource Hubs), KPI tracking, and people management. The system is built as a monolith with a Phoenix (Elixir) backend serving a custom TurboConnect API (mutation/query protocol) and a React/TypeScript single-page application frontend with a reusable component library (turboui). It also offers a CLI tool, Model Context Protocol (MCP) integration for AI agents, and extensive background job processing via Oban for notifications, email delivery, search indexing, and billing operations. The architecture follows a clean domain-driven design with operations (Ecto.Multi transactions), activity logging (event sourcing with embedded schemas), an access control system with hierarchical groups and bindings, and a rich content editor with link enrichment and blob storage. The codebase is well-tested with both backend (ExUnit, Wallaby) and frontend (Jest, React Testing Library) tests, and includes a demo data builder for development. The enterprise edition (ee/) extends the core with SaaS admin capabilities, billing management via Polar, site messages, and feature flags. The system has evolved significantly with over 115 data migrations, indicating active development. While the core architecture is solid and many patterns are reusable, there are some incomplete features (e.g., stubbed notification handlers, missing email templates) and occasional code duplication between internal API and MCP tool layers. Overall, it demonstrates strong engineering craftsmanship with practical trade-offs for an open-source SaaS application.