Netdata is a real-time, distributed monitoring and observability platform built as a multi-language agent (C core, Go collectors, Rust sidecars, legacy Python plugins). It collects system, container, application, network, and cloud metrics at per-second resolution, stores them in a custom tiered time-series database (dbengine), and exposes rich query APIs (v1/v2/v3), streaming/replication, ML-based anomaly detection, and an extensive alerting framework. The agent can operate standalone, stream to centralization points, or connect to Netdata Cloud via the ACLK (Agent-Cloud Link) using MQTT and protobuf. It also includes a network topology discovery subsystem, netflow/IPFIX/sFlow ingestion, systemd-journal log management, and an OpenTelemetry-compatible OTLP ingestion path. Architecturally, the repository is a hybrid of a daemon (C) with a plugin system that spawns many independent processes (Go, Python, shell) for metric collection. The Go plugin framework enforces a consistent collector lifecycle (config validation, init, collect, cleanup) with embedded JSON schemas and chart templates. The Rust crates handle high-throughput streams like netflow and journal indexing. The codebase is professionally engineered with extensive test coverage, benchmarks, packaging for multiple Linux distros, Windows, and macOS, and a heavy investment in performance optimizations (arena allocators, lock-free data structures, compressed bitmaps). Despite its size, it exhibits strong modularity and reusable abstractions, though some legacy duplication (e.g., Python vs Go collectors) and a few vendored components remain.
PixiJS is a mature 2D rendering library for the web (npm package pixi.js). Its production purpose is to let developers build interactive scenes, games, visualizations, and creative applications using an object-oriented scene graph and render them through WebGL, WebGPU, or Canvas backends. The core runtime is a modular TypeScript library, not a monolith: users construct Containers, Sprites, Graphics, Text, Meshes, and ParticleContainers, then a renderer collects renderables into instruction sets, batches draw calls through backend-specific adaptors and pipes, and manages GPU resources such as textures, buffers, uniform groups, and render targets via pooling and garbage-collected caches. The repository also includes an asset subsystem with loader parsers, a resolver, a cache, and format detection, plus an extension registry that allows custom systems, loaders, pipes, filters, and backend adaptors to be registered cleanly. Primary entry points are src/index.ts, the Application class with initialization and plugins (ResizePlugin, TickerPlugin, CullerPlugin), autoDetectRenderer, and the Assets API. The library depends on browser platform capabilities (Canvas 2D, WebGL/WebGPU, OffscreenCanvas, Web Workers, fetch) and small npm packages; compressed-texture support shells out to Basis/KTX transcoders. Data flows are asset ingestion (fetch/parse/cache) and GPU command generation; there is no server-side pipeline or ETL component. The codebase shows strong engineering practice: typed extension points, backend abstraction layers, performance-conscious allocation management, dual GLSL/WGSL shader support, and an extensive test suite including snapshot-based visual regression tests across WebGL1, WebGL2, WebGPU, and Canvas. Some deprecation shims and experimental features exist, but the project is actively maintained with recent commits, release automation, and active issue triage.
Chart.js is a widely adopted, open-source JavaScript library for rendering interactive data visualizations on HTML5 Canvas elements. It functions as a modular framework rather than a standalone application, providing a core engine that orchestrates controllers, scales, elements, and plugins. The architecture is designed for extensibility, allowing developers to register custom chart types, scales, and plugins via a central registry. It supports multiple output formats (ESM, CJS, UMD) and integrates with modern build tools, while maintaining compatibility with older bundlers through specific helper packages. The library handles complex data flows including numerical, categorical, and time-series data, with robust support for responsive design and device pixel ratios. It features a sophisticated animation engine that manages property interpolation and easing functions, ensuring smooth transitions during updates. The codebase demonstrates high craftsmanship in its configuration resolution system, which supports scriptable and indexable options via a proxy-based mechanism, allowing dynamic styling based on context without excessive boilerplate. Maintenance is active, evidenced by recent commits and a comprehensive test suite covering unit tests, integration tests, and visual regression tests. The project has successfully migrated to ES Modules in version 4, indicating a commitment to modern JavaScript standards. Technical drift is low, with dependencies like `@kurkle/color` and build tools like Rollup kept up to date, and the codebase actively supports browser APIs such as OffscreenCanvas and Web Workers for performance optimization.
Metabase is an open-source business intelligence platform that enables users to query, visualize, and share data through an intuitive interface. The system is built as a full-stack application with a Clojure backend and React/TypeScript frontend, supporting both self-hosted and cloud deployments. The architecture follows a modular monolith pattern with clear separation between the core application, enterprise features, and embedding SDK components. The codebase demonstrates sophisticated engineering practices including a comprehensive plugin system that allows enterprise features to extend core functionality, a custom query builder with both GUI and SQL interfaces, and a robust embedding SDK for integrating Metabase components into external applications. The frontend utilizes modern React patterns with Redux for state management, while the backend employs Clojure's functional programming strengths for data processing and API handling. Key architectural highlights include the metabase-lib library for query construction and metadata management, a sophisticated visualization system with ECharts integration, and a multi-tenant embedding solution with JWT/SAML authentication. The codebase shows strong attention to internationalization, accessibility, and performance optimization through features like query caching, lazy loading, and bundle splitting.
Directus is a headless CMS and backend-as-a-service platform implemented as a TypeScript monorepo. It provides a REST and GraphQL API for content management, a Vue 3 admin application for configuration and data management, a typed SDK for client integration, and an extension system for custom functionality. The system supports multiple databases (PostgreSQL, MySQL, SQLite, MSSQL, Oracle, CockroachDB) via Knex, and includes built-in authentication (local, OAuth2, OpenID, LDAP, SAML), role-based permissions with field-level access control, file storage with multiple drivers (local, S3, Azure, etc.), and a flows automation engine. Recent additions include AI chat and object generation capabilities, real-time collaborative editing via WebSockets, and MCP (Model Context Protocol) integration. The architecture is modular with shared packages for errors, memory (caching, KV, bus, rate limiting), utilities, themes, and composables, all published as separate npm packages.
Grafana is an open-source observability platform for querying, visualizing, and alerting on metrics, logs, and traces. It is a full-stack application with a Go backend and React/TypeScript frontend, featuring a plugin system for datasources, panels, and apps. The architecture is a monolith with Kubernetes-style API extensions, supporting multiple database backends (MySQL, PostgreSQL, SQLite). It includes built-in alerting, dashboard management, provisioning, and RBAC. The codebase is large and well-maintained, with high-quality UI components and data abstractions, but has some technical debt from dual build systems and generated code.
plotnine is a mature Python library that implements the Grammar of Graphics, closely modeled after R's ggplot2. It provides a declarative, layered API for building statistical visualizations: users compose plots by adding geometric objects (geoms), statistical transformations (stats), scales, coordinate systems, facets, themes, and guides using the `+` operator. The library renders all output through matplotlib, supporting a wide range of plot types (scatter, bar, line, histogram, density, boxplot, violin, contour, maps, etc.) with extensive customization via themes and scales. It includes built-in example datasets, animation support, plot composition (arranging multiple plots), and integration with Jupyter/Quarto. The codebase is well-structured with a clear separation of concerns (geoms, stats, scales, coords, facets, themes, guides, composition) and employs several reusable design patterns such as a registry metaclass for automatic subclass registration, dataclass-based scale definitions, a hierarchical themeable system, and a docstring generation decorator. External dependencies include matplotlib, pandas, numpy, scipy, statsmodels, mizani, and contourpy, with optional support for adjustText, geopandas, and skmisc. The project is actively maintained with weekly CI tests against bleeding-edge dependencies and a comprehensive test suite using baseline image comparison.
Apache ECharts is a mature, open-source JavaScript visualization library for building interactive charts and dashboards in web browsers. It provides a comprehensive set of chart types (line, bar, pie, scatter, map, radar, treemap, sunburst, sankey, etc.), coordinate systems (cartesian, polar, geo, parallel, calendar, matrix), and interactive components (tooltip, legend, dataZoom, visualMap, brush, timeline). The library follows a modular architecture where each chart, component, and renderer is registered via an `install` function, enabling tree-shaking and custom builds. The core rendering engine is ZRender, supporting both Canvas and SVG output, with server-side rendering (SSR) support for SVG. ECharts uses a declarative option-based API (`setOption`) and provides extensive TypeScript type definitions, internationalization (30+ locales), and theming. The codebase is well-structured with clear separation of concerns: models handle option parsing and state, views handle rendering, and a scheduler manages the rendering pipeline (layout, visual, animation). The library is production-grade, with a large test suite including unit tests, visual regression tests, and performance benchmarks. It is actively maintained by the Apache Software Foundation with frequent releases and a large community.
Gradio is a full-stack Python library and web framework for rapidly creating interactive web UIs for machine learning models, APIs, or any Python function. It provides a high-level Interface class for simple demos, a flexible Blocks API for custom layouts and event-driven apps, and a ChatInterface for chatbot applications. The backend is built on FastAPI and Uvicorn, serving both a REST API and WebSocket-based streaming. The frontend is a Svelte 5 / TypeScript application with per-component packages, a SvelteKit SSR app, and a standalone SPA that can be embedded via a custom HTML element. The library includes a rich component library (30+ input/output widgets), layout primitives (Row, Column, Tabs, Accordion, Sidebar), theming support, internationalization, and a CLI for development, deployment, and custom component creation. It also provides official Python and JavaScript client libraries for programmatic access to Gradio apps, and supports MCP (Model Context Protocol) for tool/resource integration. The repository contains over 100 runnable demos covering a wide range of ML use cases (image classification, text generation, speech recognition, object detection, chatbots, etc.), many of which integrate with Hugging Face models and datasets. While primarily an application framework, the extensive demo collection and focus on ML model visualization give it a secondary data/research character.
Recharts is a composable React charting library that renders SVG-based charts using declarative components. It provides a wide range of chart types including line, bar, area, scatter, pie, radar, radial bar, funnel, treemap, sunburst, sankey, and composed charts. The library is built on a Redux-based internal state management system with memoized selectors (reselect) for efficient rendering. It features a theming system with light/dark/auto themes, CSS transitions and custom interpolation for animations, zoom/pan controls, tooltips, legends, and responsive containers. The architecture is component-driven: each chart type (e.g., LineChart, BarChart) wraps a shared CartesianChart or PolarChart base that sets up the Redux store, data context, and event handling. External dependencies include React, Redux Toolkit, Immer, reselect, d3-shape, and victory-vendor/d3-scale. The library is published as an npm package and includes extensive unit tests, visual regression tests (Playwright), and a Storybook documentation site.
hypertools is a well‑engineered Python library for high‑dimensional data analysis and visualization, with a strong focus on animated 3D trajectories, multi‑subject alignment (Haxby hyperalignment, SRM, Procrustes), cluster analysis, time‑series forecasting, and missing‑data imputation. The package exposes a scikit‑learn–compatible Pipeline: 'manip → normalize → reduce → align → plot', plus standalone dispatchers ('hyp.plot', 'hyp.align', 'hyp.cluster', 'hyp.predict', 'hyp.impute') that share a consistent model‑spec grammar (string, class, instance, dict) and support `return_model` reuse. Two plotting backends (matplotlib and plotly) produce parity for kaleidoscopic animations (serialitary, chemo, bullet, morph) and static charts. The codebase is fortified by an audit‑driven test suite of >160 test files, many using real instead of mocked data, and delivery‑orchestrated through a coherent CI pipeline. Vendored code (PPCA, brainiak SRM, Noto Sans fonts) and a lazy‑import mechanism that auto‑installs optional extras on demand keep the core lean while enabling rich functionality.
Reflex is a full-stack Python web framework that compiles Python code into a React frontend, enabling developers to build interactive web applications entirely in Python. In production, it serves as a stateful, event-driven framework with a component system, reactive state management, and a compiler that generates JavaScript/React from Python. The architecture is a multi-package monorepo: core types and compiler (reflex-base), UI component libraries (reflex-components-* wrapping Radix UI, Recharts, Plotly, etc.), a build SDK for cloud deployment (reflex-build-sdk), a hosting CLI (reflex-hosting-cli), a durable workflow engine (reflex-workflow), observability via OpenTelemetry (reflex-otel), documentation generation (reflex-docgen), and benchmarking infrastructure (reflex-bench). Key entry points include the CLI (reflex run, reflex deploy), the Python API (rx.App, rx.State, rx.Component), and the compiler that transforms Python component trees into React code. Data flows involve user-defined state classes with computed vars and event handlers, which the compiler serializes into JavaScript state management; the server uses Starlette with Socket.IO for real-time event propagation, and state can be persisted in memory, disk, or Redis. External dependencies include Node.js, Bun, React, Radix UI, Recharts, Plotly, SQLAlchemy, Redis, Postgres, and numerous npm packages. The framework is actively maintained with extensive unit, integration, and performance tests, and it dogfoods its own documentation site.
Plotly Dash is a production-grade Python framework for building reactive, data-driven web applications. It provides a declarative callback system (server-side, clientside, background, streaming), a rich component library (core components, data table, HTML wrappers), and a React/Redux frontend renderer. The architecture supports multiple backends (Flask, Quart, FastAPI), real-time communication via WebSocket, cross-process shared storage (local, diskcache, Redis), and an MCP (Model Context Protocol) server for AI/LLM integration. The monorepo includes component generation tooling, extensive testing infrastructure (unit, integration, visual, WebSocket, background callback), and performance benchmarks. While primarily an application framework, its data table, filtering syntax tree, and shared storage subsystems demonstrate strong data engineering patterns.
Streamlit is an open-source Python framework (Apache-2.0) that converts Python scripts into interactive web applications. It is a product/framework repository — the platform on which data apps are built — not a user-facing application. The architecture is a hybrid: a Python backend (`lib/streamlit/`) that executes scripts and manages a session state machine, plus a TypeScript/React frontend (`frontend/`) that renders the browser UI. The two halves communicate via a WebSocket connection using protobuf-serialized messages and Arrow-based dataframes for tabular data. Key entry points include `streamlit run` (CLI in `lib/streamlit/web/cli.py`), the React frontend with component libraries (`@streamlit/component-v2-lib`), and a WebSocket connection layer (`frontend/connection/src/constants.ts`). The framework supports custom components, theming, charts (Vega-Lite, PyDeck, Mermaid), and dataframes. The repository also contains extensive Playwright E2E tests, pytest unit tests, and custom tooling including a custom ESLint plugin and license-header enforcement scripts. Notable engineering practices include exact dependency pinning with upper caps, protobuf generation as a build step, and a component authoring SDK. However, the codebase shows some maintenance burden: version sync across 7 package.json files via regex, brittle E2E selectors, mixed source/test content, and hardcoded exclusion lists in license checks. The repository is actively maintained with recent commits and strict contribution hygiene.
GoJS is a commercial JavaScript/TypeScript diagramming library for building interactive graphs, flowcharts, org charts, and data-visualization editors in the browser. This repository is the distribution/SDK point: it ships prebuilt core bundles (release/go.js, release/go-module.js, release/go-debug.js, release/go.mjs), TypeScript declarations (release/go.d.ts), and an extensive extension kit in both classic script (extensions/) and ES-module/TypeScript (extensionsJSM/) forms. The actual core source tree is excluded (src/ is git-ignored); users consume GoJS as an npm package or script tag and build diagram templates with a fluent API backed by GraphLinksModel/TreeModel JSON data. In production the library is a model-driven rendering and editing engine: applications push node/link data into a go.Model, declarative templates and bindings map that data to Parts, and GoJS handles canvas/SVG rendering, layout, hit-testing, undo/redo, selection, and interactive tools. There are no server endpoints or standalone executables. The extension kit is intentionally sample-grade: every file warns that APIs can change in point releases and advises copying code into the consumer's project. Despite that, the extensions demonstrate sophisticated, well-structured algorithms—circle/rectangle packing, distance-transform heatmaps, quadtree spatial indexing, SCC-based swimlane routing, and table/flow layouts—and follow consistent patterns such as option-object constructors, transaction-safe mutations, and clone-protected subclasses. No test suite is present, and the same extension is duplicated across TS, ESM JS, and classic JS, creating drift risk. License is not open-source: evaluation, non-commercial, and commercial tiers are defined in the license HTML files.
Apache Superset is a production-grade business intelligence web application for data exploration and visualization. It provides a full-stack platform (Python Flask backend, React/TypeScript frontend) that connects to over 50 SQL databases, allowing users to create interactive dashboards, design charts via a plugin architecture, execute ad-hoc SQL queries in SQL Lab, and schedule email/slack reports with screenshots. The system manages metadata in a relational database (PostgreSQL/MySQL), uses Celery for background tasks (dashboard thumbnails, report execution), Redis for caching and async events, and exposes a REST API for programmatic access. Key architectural patterns include a command pattern for CRUD operations, DAO layer for data access, a rich chart plugin system with lazy-loaded rendering, and an embedded SDK for external dashboards. The codebase is actively maintained with frequent schema migrations, extensive tests, and an experimental MCP service for AI integration. While primarily an application, it includes data-research-adjacent features like semantic layers and pandas-based post-processing for chart data.
react-map-gl is a TypeScript React component library that wraps Mapbox GL JS and MapLibre GL JS behind a declarative, reactive API. It does not render maps itself; instead it owns the lifecycle of native map instances and exposes components (Map, Marker, Popup, Source, Layer), controls such as NavigationControl and GeolocateControl, and hooks (useMap, useControl, MapProvider) that synchronize React props with the imperative map engine. The package is structured as a monorepo: a main aggregator package re-exports two per-backend packages, @vis.gl/react-mapbox and @vis.gl/react-maplibre, plus a legacy Mapbox adapter. The current line is an alpha rewrite (v8.1.0-alpha.2) focused on performance, full typing, and 1:1 prop mapping with the native map libraries.
ngx-gantt is a mature Angular library for implementing interactive Gantt charts in web applications. It provides a comprehensive set of features including task visualization with drag-and-drop resizing, dependency linking, hierarchical data structures, virtual scrolling for large datasets, internationalization support, and extensive customization through templates. The library follows Angular best practices with a modular architecture, service-based design patterns, and utilizes modern Angular features like signals. It includes a robust test suite, documentation, and automated release processes.
This repository is a collection of specialized 'Skills' for the Claude AI assistant, each designed to enhance Claude's capabilities for specific professional tasks. The McKinsey Consultant Skill implements McKinsey's Problem Solving methodology to guide users through structured business analysis and generate professional PowerPoint presentations. The Mimeng Writing Skill helps create viral Chinese-style articles by encoding specific writing techniques. The Find-session Skill assists in locating and resuming specific Claude Code conversations through grep-based search of conversation history. The US Government Shutdown Tracker Skill fetches and analyzes economic data from the FRED API to assess liquidity impacts of government shutdowns, generating visualizations and status assessments. The repository demonstrates thoughtful architecture, particularly in the McKinsey Consultant Skill's progressive disclosure approach to manage Claude's context limitations, and contains several reusable components for PPT styling, economic data analysis, and visualization.
plotters is a Rust data visualization library that provides a high-level API for creating charts and plots. It supports multiple backends (bitmap, SVG, canvas, WASM) via the `DrawingBackend` trait, allowing output to PNG, SVG, GIF, or interactive Jupyter notebooks. The core crate `plotters` offers chart builders, coordinate systems, drawable elements, series, and styles, while backend crates (`plotters-bitmap`, `plotters-svg`) implement the trait. Key entry points include `ChartBuilder`, `DrawingArea`, and backend constructors like `BitMapBackend::new`. Data flows involve user-provided iterators transformed into drawable elements via series (e.g., `LineSeries`, `Histogram`) and rendered to the chosen backend. External dependencies include `image`, `chrono`, `font-kit`, `ab_glyph`, `gif`, and `serde` (optional). The library is designed for embedding in Rust applications, not as a standalone tool, and is actively maintained with extensive examples, benchmarks, and CI.