AAChartKit is a production-ready iOS/macOS charting library that wraps the Highcharts JavaScript engine (v12.6.0) and renders interactive charts via WKWebView. The architecture is a clean Model-View separation: AAChartModel provides a chainable, declarative API for chart configuration, while AAChartView handles WebView lifecycle, JavaScript bridging, and event callbacks. A comprehensive hierarchy of option model classes (AAOptions, AAXAxis, AAPlotOptions, etc.) mirrors the full Highcharts configuration surface, allowing both high-level quick configuration and low-level full control. The library also supports JavaScript function injection via the @AAJSFunc macro for deep customization of tooltips, axes, events, and third-party Highcharts plugins, plus convenience categories for gradients, styles, and safe JS-string conversion. This is an application component library, not a data research project. The bundled demo app (AAChartKitDemo) showcases dozens of chart types from line/column/pie to advanced gauge/waterfall/boxplot with synthetic or hardcoded data. No data ingestion or analytics logic exists in the library itself—all data flows are user-supplied arrays or points passed to the chart objects. The codebase is mature, actively maintained with recent commits, and distributed via CocoaPods with an automated fastlane release pipeline. While the demo code is verbose and contains significant commented-out legacy support, the core charting API is well-structured, consistent, and demonstrates strong Objective-C craftsmanship.
butterchurn is a browser-based, real-time music visualizer that faithfully reimplements the classic MilkDrop visualizer using WebGL2. It consumes audio from the Web Audio API, runs FFT analysis to derive frequency/amplitude data, and drives a shader-based render pipeline from JSON presets that encode MilkDrop-style equations. The core library exposes a minimal `createVisualizer()` entry point, after which consumers load a preset and call `render()` with audio level data each animation frame. The library supports two equation execution paths: a JS-based expression runner and a WebAssembly/AssemblyScript-based EEL runner, with a custom Rollup plugin that compiles AssemblyScript to base64-encoded WASM at build time. It also includes deterministic seeded RNG for reproducible rendering, which is used by its visual regression test suite to compare JS and WASM paths pixel-for-pixel across a curated set of presets.
Another Graph Editor is an interactive web application for visualizing and manipulating graphs, designed with competitive programming in mind. Built with React, TypeScript, Tailwind CSS, and HTML Canvas, it allows users to input graphs in various formats (edge lists, parent-child arrays, Leetcode-style) and visualize them with multiple layout options (force-directed, tree, bipartite, grid). The application implements numerous graph algorithms for visualization including connected components, bridges and cut vertices, biconnected components, and minimum spanning trees. Users can interact with the graph through drawing, coloring, and node/edge manipulation, with support for multiple test cases and export to PNG/SVG formats.
SciencePlots is a Python library that provides curated Matplotlib style sheets for producing publication-quality scientific figures. It bundles a comprehensive set of .mplstyle files that configure figure dimensions, font families, tick marks, color cycles, and LaTeX rendering to meet the formatting requirements of academic journals, theses, and presentations. The package includes a small registration module (`styles_discovery.py`) that automatically discovers all stylesheets in its subdirectories and integrates them into Matplotlib's style system. It also offers styles tailored for specific journals (IEEE, Nature), language support (CJK, Russian, Turkish), and colorblind-safe palettes based on Paul Tol's schemes. The codebase is minimal, well-structured, and actively maintained with robust CI testing across multiple Python and Matplotlib versions. It is not a data research repo; it is a pure software library for Matplotlib customization.
AlphaGenome is a Python client library and SDK for interacting with Google DeepMind's AlphaGenome cloud service, a deep learning model that predicts molecular properties (gene expression, splicing, chromatin accessibility, histone marks, contact maps) from DNA sequence. The library provides gRPC-based clients for sequence, interval, and variant prediction, along with precomputed variant scores via the Atlas service. It includes rich data containers (TrackData, JunctionData), modular visualization components (tracks, transcripts, sashimi plots), and interpretation tools like in-silico mutagenesis. The repository also contains a set of Colab notebooks demonstrating end-to-end workflows for variant scoring, haplotype analysis, splicing quantification, and batch processing. The architecture is a thin client layer over a remote API, with protobuf definitions for service contracts and tensor serialization. Core modules handle genomic data types (Interval, Variant, Transcript), gene annotation parsing, ontology mapping, and efficient tensor packing. The variant scoring framework is extensible via dataclass-based scorers (center mask, gene mask LFC, splicing, polyadenylation) and includes utilities to tidy AnnData results into pandas DataFrames. Visualization is component-based, allowing composition of tracks, contact maps, and annotations into publication-quality figures. While primarily an application library, the repo has a strong data research character due to its focus on genomic analysis and the included notebooks. The code is well-structured, with extensive unit tests and CI/CD pipelines. However, it is tightly coupled to the AlphaGenome API and protobuf definitions, limiting standalone reuse. The most reusable components are the data containers (TrackData, JunctionData), tensor packing utilities, and the variant scorer dataclass pattern, which could be extracted for other genomic scoring tasks.
git-sim is a CLI tool that generates visualizations of Git operations from within a local repository. It uses the Manim animation library to render commit graphs, branches, tags, and file states as either static images (JPG/PNG) or animated videos (MP4/WEBM). The architecture is built around a base class `GitSimBaseCommand` that extends Manim's `MovingCameraScene` and provides common drawing methods for commits, refs, arrows, and zone tables. Each Git subcommand (add, branch, checkout, merge, etc.) is implemented as a separate Python class that inherits from this base class and overrides the `construct()` method to build the specific scene. The CLI interface is defined using Typer, and the application reads the current Git repository state via GitPython. The animation output is handled by a dedicated `handle_animations` function that manages rendering, format conversion, and file output. The codebase is well-organized, with clean separation between command logic, animation rendering, and configuration management via Pydantic settings. It demonstrates effective use of the Manim library for non-trivial graphics and provides a robust framework for simulating Git commands.
pythonocc-core is a Python binding for the OpenCASCADE Technology (OCCT) 3D CAD kernel, providing full access to OCCT's geometry, topology, visualization, and data exchange capabilities. It is a library, not a standalone application, designed for engineers and developers building CAD/CAE/PLM tools in Python. The architecture is a C++ extension module generated via SWIG, with a thin Python layer that adds convenience utilities, multiple display backends (Qt, wxPython, Tkinter, WebGL/Jupyter), and high-level helpers for shape creation, topology traversal, and file I/O (STEP, IGES, STL, glTF, OBJ, PLY). The core API mirrors OCCT's class hierarchy, while the `OCC.Extend` and `OCC.Display` packages provide Pythonic wrappers and interactive 3D viewers. The repository is actively maintained, with recent releases (7.9.3) and CI pipelines for conda packages across platforms. It includes extensive type stubs for IDE support, a comprehensive test suite, and support for offscreen rendering and Jupyter notebooks. Key entry points include `OCC.Display.SimpleGui.init_display()` for interactive viewers, `OCC.Extend.DataExchange.read_step_file()` for CAD file import, and `OCC.Core.Tesselator.ShapeTesselator` for mesh generation. The codebase demonstrates strong engineering practices with reusable patterns like the topology explorer, shape factory utilities, and a generic proxy pattern for OCCT objects. However, the SWIG-generated wrapper layer is large and fragile, requiring careful version alignment with OCCT, and some OCCT classes remain unwrapped.
Plots.jl is a comprehensive, multi-backend plotting library for Julia, organized as a monorepo containing several interdependent packages: PlotsBase (core plotting infrastructure), RecipesBase/RecipesPipeline (a macro-driven recipe system for defining custom plot types), GraphRecipes (graph and tree visualization), StatsPlots (statistical plots like boxplots, violin plots, histograms, and correlation plots), and PlotThemes (color themes). The library provides a unified API over backends including GR, PythonPlot, PlotlyJS, PGFPlotsX, UnicodePlots, and Gaston, allowing users to switch between interactive and static output without changing code. The architecture is centered on a preprocessing pipeline that transforms input data and attributes through alias resolution, magic argument expansion, and recursive recipe application before delegating to the chosen backend. This design enables extensibility: package authors can define new plot types via the lightweight RecipesBase dependency without pulling in the full Plots stack. While primarily a general-purpose visualization library, it includes strong support for scientific and research workflows through statistical plots, graph layouts, unitful quantities, HDF5 persistence, and animations. The codebase is large and macro-heavy, with some backends lagging in feature parity and occasional deprecated API usage, but overall it is actively maintained and well-tested.
Prismaliser is a fully client-side single-page application that visualizes Prisma database schemas as interactive entity-relationship diagrams. It runs entirely in the browser: the user pastes a Prisma schema into a Monaco editor, the app parses it client-side via a vendored WASM module from Prisma's own schema parser, and renders the models, enums, and relations (1-1, 1-n, m-n) as an interactive React Flow graph. The app has no backend server – it is a static Vite SPA that can be self-hosted (Docker image provided). Recently, AT Protocol (Bluesky) integration was added allowing users to publish immutable snapshots of their diagrams (schema + node positions) to their own AT repository, share via canonical AT links, and manage published snapshots. OAuth login is browser-native using the atcute library family. The codebase is TypeScript strict, thoroughly tested (Vitest), and follows modern React patterns with Tailwind CSS v4 and CSS modules. The architecture is modular: a util layer handles Prisma parsing, graph generation, and layout (elkjs), while a dedicated atproto/ module handles OAuth, record creation, public retrieval, and share link parsing. The UI is built with React 19, using local state and hooks (no global state management). The project is actively maintained with recent commits and open issue triage.
RViz is a 3D visualization tool for the Robot Operating System (ROS) that provides real-time visualization of sensor data, robot state, and navigation information. The application features a plugin-based architecture where displays, tools, and view controllers are dynamically loaded, enabling extensibility for various data types. Built with Qt for the GUI framework and Ogre for 3D rendering, RViz processes ROS messages through display plugins that convert data into renderable objects in the scene. Key systems include a property hierarchy for configuration, resource loading from ROS packages, and YAML-based configuration persistence. The architecture centers around a VisualizationManager coordinating the render loop, with core components including Display (visualization base), Tool (interaction base), and ViewController (camera control base). Data flows from ROS topic subscriptions through display plugins that process messages and update Ogre scene objects. User interactions via tools may publish ROS messages (e.g., setting navigation goals). The system maintains strict separation between Qt GUI elements, Ogre rendering, and ROS communication layers, using signals/slots for inter-component communication. Despite its complexity, RViz incorporates several reusable, well-engineered components. The property system provides a robust framework for editable parameters with automatic GUI generation and validation. The plugin architecture, built on pluginlib, offers a clean extension mechanism. Ogre helpers encapsulate common rendering tasks, and the configuration system handles hierarchical settings with locale-independent number parsing. The project shows active maintenance with ongoing efforts to modernize dependencies (Qt, Ogre, C++), though it remains primarily focused on ROS 1 with acknowledged technical debt regarding ROS 2 migration.
This repository is an interactive, cyberpunk-styled periodic table of elements web application. It displays all 118 elements with detailed data, supports multiple visualization modes (standard, heatmap for properties like radius, electronegativity, ionization energy, melting point, boiling point, density), category filtering, real-time search, and a 3D atomic model viewer. The application is fully bilingual (Chinese/English) and responsive across devices. The architecture is a single-page application built with TypeScript and Vite. The codebase is modular, with clear separation into modules for table rendering, heatmap, 3D atom, modal, media loading, search, and legend. State is managed centrally, and internationalization is handled via typed translation dictionaries. The project includes unit tests using Vitest and a CI/CD pipeline for GitHub Pages deployment. Key technical highlights include a pure-function electron configuration algorithm (Aufbau principle with exceptions), CSS 3D transforms for the atom model, and a lightweight i18n system. The code is type-safe with strict TypeScript and follows modern frontend best practices.
DeaDBeeF is a cross-platform desktop music player with a modular plugin architecture. It supports a vast array of audio formats including MP3, AAC, FLAC, Ogg Vorbis, Opus, WavPack, Musepack, DTS, and numerous chiptune and video game music formats (SID, NSF, VGM, MOD, S3M, XM, IT, PSF, etc.) through bundled emulation libraries. The core player handles playlist management, metadata caching, replaygain, DSP chain processing, and streaming. Two native GUI implementations exist: a GTK2/GTK3 interface for Linux and a Cocoa interface for macOS, both offering full-featured playback controls, media library browsing, cover art display, and visualization (scope, spectrum analyzer). The player also includes a converter plugin, MPRIS integration, and extensive keyboard shortcut customization. The architecture is centered around a lightweight plugin API (DB_plugin_t) that decouples decoders, outputs, DSP effects, and UI components. The core library (libdeadbeef) provides threading, file I/O, configuration, and message passing. Plugins are loaded dynamically and register themselves via a factory pattern. The media library plugin uses SQLite for indexing and file system watchers (inotify on Linux) for automatic updates. Artwork is fetched from embedded tags and online services (Last.fm, MusicBrainz) with a local cache. The build system uses autotools, premake5, and Xcode projects, with Docker-based CI for Linux, macOS, and Windows. Key data flows include: file opening via VFS abstraction → decoder plugin → decoded audio blocks (ring buffer) → DSP chain → output plugin. Metadata flows from file tags through a caching layer to the UI and media library. The player supports CUE sheets, gapless playback, and crossfading. External dependencies include GTK2/GTK3, libcurl, libsamplerate, and various codec libraries (libmpg123, libmad, libvorbis, libFLAC, etc.), many of which are bundled as source for portability.
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.
FlowGram is a comprehensive, production-grade visual workflow development framework from ByteDance. The codebase implements two distinct editing paradigms — fixed-layout (automatic positioning with composite nodes like loops, branches) and free-layout (node-position-free with lines) — both built on a shared plugin architecture using inversify for dependency injection. The framework includes a form engine with reactive fields, validation, and effects; a variable engine with AST-based type inference and scoped lifecycle; and a runtime engine capable of executing workflows with executors for LLM, HTTP, code (QuickJS sandbox), and conditions. The repository contains over 40 packages managed via Rush monorepo, encompassing core libraries, plugins (history, minimap, auto-layout, group, snap, clipboard, export), UI material libraries (Semi UI, Ant Design), a CLI tool for scaffolding, multiple demo applications, and comprehensive documentation. The system is actively maintained with regular commits, CI workflows, and E2E tests. Notable technical decisions include a local fork of the use-gesture library for canvas interaction, heavy decorator-based IoC, and support for both React 17 and 18. While the architecture is well-structured and extensible, the codebase shows signs of duplication between fixed and free layouts, numerous demo-specific components, and some deprecated APIs that indicate ongoing refactoring.
Gitlogue is a terminal-based Git history visualizer that replays commits as a cinematic typing animation with syntax highlighting. It loads a local Git repository, extracts diffs, and renders the changes character by character in a split-pane terminal interface (ratatui). The core architecture is a monolithic Rust binary using clap for CLI, git2 for Git operations, tree-sitter for syntax highlighting across 32 languages, and crossterm for terminal I/O. It supports multiple playback modes (random, chronological, watch) and includes a configuration system, 17 built-in themes, and a custom animation engine with step-based simulation and checkpoint/restore. Notable reusable components include the SelectableParagraph widget (isolated ratatui component for text selection and dimming) and the Theme system (extensible struct with ~40 named colors). The codebase is well-structured but exhibits moderate technical drift risk due to heavy tree-sitter dependency chain, rapid feature growth, and potential staleness with some language grammare updates. CI/CD is active but the release workflow is manual. Overall, gitlogue is a solid, professional terminal application that effectively delivers its claimed functionality.
Plow is a high-performance HTTP(S) benchmarking CLI tool written in Go. It uses fasthttp for efficient HTTP client operations and provides real-time metrics including latency statistics, percentiles, histograms, and throughput. The tool supports configurable concurrency, request rate limiting, ramp-up, duration-based or request-count-based runs, and custom headers, body, TLS, and proxy settings. It outputs results to the terminal with live updating tables and also serves a web UI with interactive charts (latency, RPS, status codes, concurrency) using go-echarts. The architecture is a single binary with three main components: a requester that spawns concurrent workers, a stream-based report aggregator that computes streaming quantiles and histograms, and a printer/chart server for output. The code is well-structured, thoroughly tested, and follows Go best practices. It is not a library but a standalone application, though some internal components (e.g., the streaming stats engine and throughput interceptor) are cleanly isolated and could be reused in other projects.
MSTICpy is a Python library for cybersecurity threat hunting and investigation, primarily designed for use in Jupyter Notebooks. It provides a unified interface to query multiple data sources (Azure Sentinel, Splunk, Kusto, MDE, etc.), enrich data with threat intelligence and geolocation, perform anomaly detection and process tree analysis, and visualize results with interactive timelines, maps, and graphs. The architecture follows a modular, plugin-based design: data drivers abstract away backend-specific protocols, threat intelligence providers are registered via a consistent base class, and a pivot framework dynamically attaches investigation functions to entity types. The library also includes configuration editors, Azure authentication helpers, and notebook widgets to streamline analyst workflows. While the core purpose is security analysis, the repository also contains substantial research-oriented components, such as anomalous sequence detection (Markov models on command sessions), time-series anomaly detection, and event clustering. These are packaged alongside the production-grade query and enrichment infrastructure, making the repo a hybrid of an application library and a data analysis toolkit. The codebase is well-tested with extensive unit and integration tests, though many require mocked or optional external services. Key entry points include the `QueryProvider` class for data acquisition, `TILookup` for threat intelligence, `Pivot` for entity-driven investigations, and the `mp` pandas accessor for inline transformations. External dependencies span Azure SDK, Bokeh, ipywidgets, and multiple third-party APIs, which introduces some maintenance overhead. Overall, MSTICpy is a mature, actively maintained tool that demonstrates strong engineering practices with reusable patterns, but some modules show signs of version drift and compatibility workarounds.
This repository contains a Jupyter notebook that processes Strava data exports to generate interactive running heatmaps. The core functionality involves parsing GPS and sensor data from .fit.gz files, filtering activities by type and date, detecting a home location, rasterizing GPS tracks into multiple value grids (frequency, pace, heart rate, gradient, elevation change), applying Gaussian blurring and normalization, and rendering the results as overlay layers on a Leaflet basemap via Folium. The output is a single HTML file with six toggleable layers showing different aspects of running patterns. The code demonstrates solid data processing techniques including efficient caching, coordinate transformations, and custom visualization logic, though it remains tightly coupled as a monolithic notebook.
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.