Matplot++ is a C++ graphics library for data visualization that provides a MATLAB-like API for creating publication-quality plots. It supports a wide range of plot types including line, scatter, bar, histogram, surface, contour, polar, geographic, and 3D plots, as well as image display, graph visualization, and annotations. The library is designed for scientific computing and engineering applications, offering both free-standing function calls and an object-oriented interface with method chaining. It features a pluggable backend architecture with Gnuplot as the primary rendering backend (via pipe communication) and an experimental OpenGL backend. The library handles data transformation, automatic tick calculation, colormap interpolation, contour generation (adapted from Matplotlib), histogram binning with multiple algorithms, and geographic map rendering using bundled Natural Earth data. External dependencies include Gnuplot 5.2.6+ at runtime, with optional support for image processing libraries (CImg, JPEG, TIFF, PNG, OpenCV) and numerical libraries (FFTW, LAPACK, BLAS). The build system is CMake-based with comprehensive options for testing, examples, and documentation generation. Architecturally, the library is organized around a core figure-axes-object hierarchy: figure_type manages the canvas and backend, axes_type holds plot objects and axis configuration, and individual plot types (line, bars, histogram, etc.) inherit from axes_object and implement backend-specific rendering methods. Free-standing functions in freestanding/ forward calls to the current axes via a global figure registry. The backend interface abstracts rendering commands, allowing the same plot objects to work with different backends. The library includes a large set of examples (200+) that serve as both documentation and integration tests, and a documentation pipeline that auto-generates a gallery from example executables. Key entry points for users are the matplot.h header and the free-standing functions (plot, hist, surf, etc.). The library is consumed via CMake's find_package or as a subdirectory. It supports both interactive (reactive) and non-interactive (quiet) modes, and can save plots in multiple formats (SVG, EPS, PNG, PDF, etc.) through backend-specific commands.
MDV (Markdown Data & Visualization) is a tool that extends CommonMark Markdown with front-matter, fenced code blocks for charts/tables/stats, `:::` container directives for layout and styled regions, and auto-generated table of contents. It parses `.mdv` files and renders them to self-contained HTML with inline SVG charts (bar, line, pie) and CSS themes, requiring no JavaScript runtime in the output. The project is a TypeScript monorepo with three packages: `@mdv/core` (parser and renderer library), `@mdv/cli` (CLI with render, preview, and PDF export commands), and `mdv-vscode` (VS Code extension providing live side-by-side preview). The parser uses `markdown-it` as a base with a fence-aware preprocessor that handles `:::` directives and HTML comments correctly within code blocks. The renderer is designed for robustness: errors never crash the document, invalid front-matter renders a fatal banner, and chart data validation produces inline error messages. Security measures include escaping raw HTML, sanitizing style values, and preventing path traversal in data file references. The CLI supports live preview with file watching and auto-reload, and PDF export via headless Chromium (Puppeteer). The VS Code extension provides a debounced live preview that also refreshes on data file changes.
This repository is the canonical ADC Performance Survey dataset maintained by Boris Murmann. It aggregates published ADC (analog-to-digital converter) performance data from ISSCC and VLSI Symposium papers between 1997 and 2026. The primary data artifact is an Excel workbook (xls/ADCsurvey_latest.xlsx) that is consumed by a set of Jupyter notebooks under plots/ to generate publication-quality figures such as FOMs plots, energy plots, aperture trend plots, and FOM trend plots. The repo also contains PDF resources and a short course presentation.
Redash is a full-stack business intelligence platform that enables users to connect to multiple data sources, write and schedule queries, build interactive visualizations, and create dashboards with alerting and sharing capabilities. The backend is a Python Flask application with SQLAlchemy for database access, Redis for caching and task queuing, and RQ for background job execution. The frontend is a React single-page application using Ant Design, Plotly, D3, and Leaflet, organized into pages for queries, dashboards, alerts, data sources, and administration. The system exposes a RESTful API for all operations and supports authentication via password, Google OAuth, SAML, LDAP, JWT, and API keys. The architecture follows a modular plugin pattern for query runners and visualizations. Over 35 query runners (e.g., PostgreSQL, BigQuery, Snowflake, MongoDB, Prometheus) are registered via a common base class, each implementing run_query, get_schema, and configuration_schema. The visualization library (viz-lib) is a separate package that registers chart types (line, bar, pie, map, table, cohort, sankey, etc.) with editors and renderers. Dashboards use a grid layout with widgets that can display visualizations, text, or embedded content. Alerts evaluate query results against conditions and send notifications to destinations like Slack, email, PagerDuty, and webhooks. Key data flows: users write SQL or use query runners to fetch data from connected sources; results are cached and can be visualized; dashboards aggregate multiple visualizations with parameter bindings; scheduled queries refresh results and trigger alerts. The system also supports embedding visualizations in external sites and public sharing of dashboards. While primarily an application, the extensive query runner and visualization plugin systems make it a flexible platform for data exploration and operational reporting.
DataEase is a self-hosted, open-source business intelligence (BI) platform that enables users to connect to diverse data sources, build datasets, create interactive charts and dashboards, and share insights via links or embedded widgets. The codebase is a full-stack monolith with a Java Spring Boot backend (JPA, Calcite SQL parser, Quartz scheduling) and a Vue 3 frontend (AntV G2/G2Plot/L7 for charts, UniverJS for spreadsheets). It supports a wide range of database connectors (MySQL, PostgreSQL, Oracle, ClickHouse, StarRocks, Elasticsearch, MongoDB, etc.), dataset types (SQL, union, custom fields), chart types (bar, line, pie, map, table, indicator, etc.), and enterprise features like row/column-level permissions, scheduled sync, report delivery, and multi-factor authentication. The architecture includes an SDK layer for extensions (datasource providers, sync providers, chart plugins) and a separate Xpack module for commercial features. The platform is deployed via Docker Compose with APISIX gateway. The codebase is actively maintained (24k+ stars, recent commits) but exhibits some technical drift due to deep inheritance hierarchies in chart handlers, code duplication across engine providers, and tight coupling to specific library versions (AntV G2, UniverJS). Overall, it is a solid, production-grade BI tool with good separation of concerns but with room for refactoring in certain areas.
YouPlot is a command-line tool for creating plots in the terminal using Unicode characters. It reads delimited data from stdin or files, parses it into headers and series, and generates various plot types (barplot, histogram, lineplot, scatter, density, boxplot, count) using the UnicodePlot backend. The tool follows Unix conventions, designed for use in data pipelines with options to pass through input data and output plots to stderr/stdout. It features progressive mode for real-time data visualization and supports configuration via CLI flags, config files, and sensible defaults.
The kjhealy/socviz repository is an R package that provides curated datasets and utility functions for teaching data visualization using ggplot2, primarily as a companion to the book "Data Visualization: A Practical Introduction" (2nd edition, 2026). It bundles approximately 30 social science datasets sourced from US Census Bureau data (county demographics, poverty), the General Social Survey, US election results (historic through 2024), OECD economic indicators, FRED time series, opiate mortality, and others. These datasets are clean, well-documented, and compressed for efficient loading via `data()`. The package also includes small utility functions (e.g., `theme_socviz`, `%notin%`, `round_df`) that support common data visualization workflows. While the primary value lies in the ready-to-use datasets rather than complex transformations, the package is properly structured with roxygen2 documentation, pkgdown site, and CRAN CI checks. It is a solid resource for educators and students learning R graphics, though reproducibility of the raw data pipelines depends on external sources that may change over time.
C3.js is a D3-based charting library that provides a high-level, configurable API for generating interactive SVG charts directly in the browser. The library supports a wide range of chart types including line, bar, area, pie, donut, gauge, scatter, spline, step, and the specialized Stanford diagram. It handles data ingestion from multiple formats (JSON, CSV, TSV, rows, columns) and offers features such as zooming, subcharts (brush), legends, tooltips, grid lines, regions, and animated transitions. The core is driven by a single configuration object passed to c3.generate(), which controls all visual and behavioral aspects. Architecturally, C3.js follows a classic prototype-extension pattern: the ChartInternal class holds the rendering logic, and each chart type and API method is added via prototype extensions. The public API is exposed through a Chart instance returned by the factory function. The library is self-contained, depending only on D3.js (v5) and runs entirely client-side. It includes polyfills for older browsers (SVGPathSeg, String.padEnd, Object.assign) and has been tested with Jasmine/Karma in a headless browser environment. The codebase exhibits good modularity within a single-bundle approach: internal modules (e.g., data conversion, color scales, axis rendering, tooltip) are logically separated in the source directory. However, the bundled output is monolithic, making tree-shaking difficult. The project is well-documented with sample pages and a documentation site built with Middleman (Ruby). Maintenance has been stable but slow; the latest version is 0.7.20 with no major releases in recent years. The dependency on D3 v5 (instead of v7) and the presence of IE-specific polyfills indicate some technical drift. Despite this, the code is functional, well-tested, and still widely used. It demonstrates a strong real-world application of D3 for reusable chart components.
Frappe Insights is a full-stack business intelligence application enabling users to connect to data sources, build queries visually or via SQL, create visualizations, and assemble dashboards and workbooks. The decoupled architecture features a Vue.js 3 frontend communicating with a Python/Frappe backend through REST APIs. Key capabilities include a multi-database query builder using Ibis and SQLGlot, ECharts-powered visualizations, role-based access control, and DuckDB-based data warehousing for caching imported tables. The frontend leverages Vue composition API for reusable logic, while the backend uses Frappe's DocType system for extensibility. The project demonstrates solid engineering practices with modular API design, reusable components, and abstraction layers, though complexity arises from supporting numerous database types and deep Frappe integration.
A full-stack personal running activity dashboard that syncs workout data from over a dozen platforms (Strava, Garmin, Nike, Keep, Coros, etc.) via Python scripts, stores it in SQLite, and renders interactive web visualizations (React + Mapbox) and SVG posters (grid, heatmap, year summaries). It also includes a terminal UI (Textual) and an optional AI-powered share image generator. The architecture is a hybrid monolith: a shared SQLite database backs both the frontend (exported as JSON) and SVG generation. The frontend is themeable with two built-in themes (classic, dashboard). While the sync scripts are tightly coupled to each provider's API, the SVG poster drawer library and the terminal UI's data aggregation layer are well-isolated and potentially reusable. The project is actively maintained with frequent commits, CI/CD pipelines, and Docker support, though it carries moderate technical drift due to many unpinned dependencies and reliance on third-party APIs that may change.
Three-forcegraph is a reusable JavaScript library for creating 3D force-directed graph visualizations using Three.js. It implements a reactive component that takes graph data (nodes and links) and renders them in 3D space using either d3-force-3d or ngraph.forcelayout for physics simulation. The library provides extensive customization options for node/link appearance, behavior, and layout constraints including DAG modes, directional arrows, and particle effects. Built with the Kapsule pattern for state management, it follows a modular architecture separating core logic, utilities, and Three.js object management. The library handles proper resource disposal to prevent WebGL memory leaks and offers both imperative and declarative APIs for integration into web applications.
This repository maintains a comprehensive Python cheatsheet available as a web application and printable PDF. The core content resides in README.md, which is converted to a multi-page website via parse.js. The web version features interactive elements like theme switching and a table of contents, and includes live-updating data visualizations (e.g., COVID-19 trends) refreshed by update_plots.py. Supporting scripts handle PDF generation, index creation, and table format conversion. While the cheatsheet content is exceptionally well-curated, the supporting codebase consists of specific-purpose scripts with moderate coupling, limiting broad reuse outside this project.
This repository is a curated list of awesome Jupyter projects, libraries, and resources. It serves as a reference for developers and data scientists seeking tools to enhance their Jupyter experience, including runtimes, visualization libraries, collaboration tools, and more. The list is organized into thematic categories (e.g., Runtimes/Frontends, Collaboration/Education, Visualization) for easy navigation and discovery. The repository includes maintenance workflows to ensure the quality and consistency of the list. A GitHub Actions workflow runs awesome-lint and remark-lint to validate the format of the list and keep it alphabetized. Another workflow tracks GitHub traffic statistics. The project follows standard contribution guidelines and is licensed under Creative Commons Attribution-ShareAlike 4.0. While the repository itself does not contain executable code or data, it provides significant value as a discovery tool for the Jupyter ecosystem. The maintained workflows demonstrate good practices for keeping awesome lists clean and consistent, which can be reused in similar projects. The content is regularly updated, as evidenced by recent commits, indicating active maintenance.
The Little Book of ML Metrics is a comprehensive, collaboratively authored reference book that explains and visualizes evaluation metrics across the full spectrum of machine learning tasks: regression, classification, clustering, ranking, computer vision, NLP, generative AI, probabilistic estimation, bias/fairness, and data observability. The repository contains the LaTeX source code, a collection of Jupyter notebooks (and Python scripts) that generate all figures, and a set of custom tools for book production and review. Its primary function is to produce a high-quality, print-ready PDF that serves as both a pedagogical introduction and a practical decision guide for practitioners. The codebase is dominated by figure-generation scripts that implement each metric with synthetic or small real-world datasets and render Tufte-style, publication-quality plots. While the repository is not a traditional software application, it does include several bespoke tools: an interactive formula tuner (for adjusting TikZ arrow annotations on formulas), a review recorder (a local HTTP server for reviewing the PDF with audio notes), and a formula layout helper that auto-positions arrows. These tools are tightly integrated into the book production pipeline but are not intended for general reuse. The code is well-organized and follows consistent visual patterns (shared color palette, despine helpers, direct annotations), though there is considerable duplication across notebook scripts and a lack of automated tests. The LaTeX build process is robust but depends on a full TeX distribution and a third-party GitHub Action. Dependencies are pinned via pyproject.toml and uv.lock, and the genai figure generation requires a separate heavy environment (torch, transformers) run manually, which reduces full reproducibility out-of-the-box. Overall, this is a well-crafted book project with strong internal consistency, but its code is best viewed as supporting infrastructure rather than a standalone piece of software.
This repository is a community-driven collection of Streamlit 'extras' — custom components and utilities that extend Streamlit's functionality. It is a Python library (package `streamlit-extras`) that provides over 40 self-contained subpackages, each implementing a specific UI widget, layout helper, or data exploration tool. The architecture is modular: each extra is a subpackage under `src/streamlit_extras/` with a standardized metadata convention (`__title__`, `__desc__`, etc.) and a central `@extra` decorator for registration. Some extras are pure Python wrappers around Streamlit's native APIs (e.g., `grid`, `stateful_button`, `stoggle`), while others are full Custom Components v2 (CCv2) with React/TypeScript frontends built with Vite (e.g., `three_viewer`, `json_editor`, `sigma_graph`). The build system uses Hatch with a custom build hook to compile React frontends during wheel packaging. The gallery app (`gallery/streamlit_app.py`) serves as a demo and documentation explorer. The codebase is well-organized but has several deprecated extras that rely on private Streamlit APIs, and test coverage is limited to metadata validation. Overall, it is a solid, actively maintained library with reusable patterns for Streamlit component development.
Kanaries/Rath is an open-source augmented analytics BI platform that automates exploratory data analysis, causal discovery, and dashboard creation. It is a full-stack application with a React/TypeScript frontend (Vite, MobX, shadcn/ui) and multiple Python microservices (causal inference, narrative insight generation, database connectors). The system ingests data from files, databases (PostgreSQL, ClickHouse, MySQL, etc.), and REST APIs, then provides automated visualization (mega-automation), semi-automated exploration, causal analysis (PC, FCI, GES, XLearner), and interactive dashboard building. It also includes custom Vega renderers (WebGL, Painter) for high-performance chart rendering and an Electron desktop wrapper. While primarily an application, it contains significant data research components such as causal discovery algorithms, statistical insight detection, and text pattern extraction, making it a hybrid tool for both data exploration and advanced analytics.
city-roads is a browser-based single-page application that fetches OpenStreetMap road data and renders every road in a chosen city as WebGL line art. Users search for a city; the app geocodes the query via Nominatim, suggests administrative boundaries, and then loads data either from a prebuilt protobuf cache hosted on CloudFront/S3 or from the Overpass API. The downloaded OSM nodes and ways are parsed into a Grid object, projected into 2D local coordinates with a Mercator projection, and pushed into a w-gl WireCollection for fast canvas rendering. The UI supports changing road, background, and label colors, editing the city label, saving PNG and SVG exports, and generating Zazzle mug links. A console API exposed as window.scene and window.Query lets advanced users run arbitrary Overpass queries and compose multiple city layers. Architecturally it is a Vue 3/Vite frontend with a clean separation between small lib modules (request, progress, grid, query builders, exporters) and UI components. There is no backend; all data comes from OSM and Nominatim public services plus a static cache. The repository is primarily an application rather than a data-research project, but its lib layer contains genuinely reusable geospatial and Overpass utilities. The codebase is compact, mostly readable, and handles real-world failure modes such as Overpass mirror outages, large downloads, cancellation, and high-resolution exports. Notable weaknesses are the absence of automated tests and CI, leftover Vue CLI configuration, outdated dependencies (Vite 2, Vue 3.2), a debugger statement in App.vue, and a broken custom-projector branch in LoadOptions. Overall it is a solid, functional visualization app with several modular components that could be extracted for other OSM or WebGL projects.
ggprism is an R package that extends ggplot2 to replicate the visual aesthetics of GraphPad Prism. It provides themes, color/fill/shape palettes, and specialized geoms/guides to create publication-ready plots matching Prism's default styling. Key functionalities include applying Prism-like themes via `theme_prism()`, using discrete palettes with `scale_*_prism()` functions, adding statistical annotations (e.g., p-value brackets) with `add_pvalue()` and `geom_bracket()`, and customizing axes with specialized guides like `guide_prism_offset()` for offset ticks. The package follows ggplot2 extension conventions, using ggproto for custom geoms, discrete_scale for scales, and guide objects for axis modifications. It includes built-in datasets (e.g., wing morphology data) and relies on standard R datasets in examples. External dependencies center on ggplot2, scales, and rlang, with optional packages like ggnewscale and patchwork used in vignettes.
VASPy is a pure Python library for manipulating and analyzing VASP (Vienna Ab initio Simulation Package) input and output files. It provides object-oriented parsers for common VASP formats including POSCAR, CONTCAR, XDATCAR, OUTCAR, OSZICAR, INCAR, DOS, ELFCAR, CHGCAR, and also supports Materials Studio formats (XSD, ARC, XTD). The library exposes high-level classes like PosCar, OutCar, DosX, and InCar that encapsulate file parsing, coordinate transformations, and data extraction, enabling users to programmatically read, modify, and visualize simulation results. It also includes a set of command-line scripts for common tasks such as creating VASP inputs, extracting forces, computing zero-point energies, and converting between file formats. The architecture is modular, with separate modules for atomic coordinates, electronic structure, iterative outputs, and Material Studio interoperability, all built on a shared base class and utility functions. Visualization is a key feature, with matplotlib and PyVista backends for plotting DOS, charge densities, and trajectories. The library is designed for computational materials science researchers and DFT practitioners who need to automate post-processing and workflow tasks around VASP calculations.
This repository provides ECMAScript compatibility tables for JavaScript engines, browsers, and compilers. It ingests test definitions (embedded as commented JavaScript code) and expected results per engine version, then builds static HTML pages via Node.js scripts. The data covers ES5 through ES2025+ proposals, Intl, and non-standard features, with thousands of subtests mapped to hundreds of engine versions. The codebase is primarily a data pipeline with a build system (using cheerio for HTML generation) and optional test runners that execute tests against real engines (e.g., Duktape, GraalVM) to validate or update results. The output is the well-known kangax.github.io/compat-table static site. While the data is meticulously maintained, the repository is not a reusable library or application; it is a specialized data project with moderate reproducibility due to reliance on external engine binaries and outdated dependencies like jQuery 1.12.