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.
Vegeta is a versatile HTTP load testing tool and Go library. It simulates constant-rate or oscillating traffic against HTTP endpoints, collects latency and byte metrics, and generates reports (text, JSON, histograms, HTML plots). The core is an attack engine with pluggable pacers, a targeter for reading HTTP request specs, and a metrics pipeline using t-digest for percentile estimates. It includes a Prometheus exporter and a downsampling library for plotting large time series. The codebase is well-structured with clean package boundaries, cross-platform support, and extensive testing including fuzzing.
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.
matplot2tikz is a Python library that converts matplotlib figures into PGFPlots/TikZ code for native inclusion in LaTeX or ConTeXt documents. It recursively traverses a matplotlib Figure tree, translating each artist (lines, patches, images, colorbars, legends, text, etc.) into corresponding PGFPlots commands. The library provides two main entry points: `get_tikz_code()` returns the TikZ code as a string, and `save()` writes it to a file. It also includes a `clean_figure()` function that simplifies paths and reduces data points to minimize output size while preserving visual fidelity. The architecture is modular, with dedicated modules for each artist type (e.g., `_line2d.py`, `_patch.py`, `_axes.py`), a central data class (`TikzData`) to carry configuration and state, and a recursive traversal in `_save.py`. External dependencies include matplotlib, numpy, Pillow, and webcolors. The codebase is well-tested with over 170 test files and uses modern Python tooling (ruff, mypy, tox). It is a fork of the unmaintained tikzplotlib and is actively maintained with recent commits and CI.
FigMirror is a reference-conditioned scientific figure style transfer system that iteratively generates matplotlib scripts matching the visual style of a reference figure. It operates as a multi-agent loop (Drawer/Reviewer) orchestrated by a runner backend (Codex, Claude, or Mock), with a local web UI for upload, iteration browsing, and refinement. The system is packaged as skills for both Claude Code and Codex, plus a standalone web server. While primarily an application, it has a strong research component: the prompts, aesthetic library, and evaluation benchmarks (PlotTwin-Bench) are the result of extensive empirical iteration. The codebase demonstrates high craftsmanship in its runner architecture, atomic file operations, SSE streaming, and deterministic review gates. However, it suffers from dual skill bundles (Claude/Codex) that must stay synchronized, retired artifacts, and some incomplete features (ClaudeRunner, SSE integration).
PyPlot.jl is a Julia package that provides a direct interface to the matplotlib.pyplot library from Python, enabling Julia users to create plots using Matplotlib's extensive plotting capabilities. The package uses PyCall to call Matplotlib functions with minimal overhead, passing Julia arrays without copying. It integrates with Julia's multimedia I/O system to display plots in various backends (including IJulia, Jupyter, and GUI windows) and supports automatic backend selection based on available dependencies. The architecture consists of a core module handling the PyPlot interface, separate modules for colormap management and 3D plotting, and initialization code that configures the Matplotlib backend and sets up integration with Julia's display system. Key features include support for LaTeX in plot labels via LaTeXStrings, automatic figure management in interactive environments, and compatibility with both Julia-based and Python-based GUI backends.
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.