Monorepo for node-based graph/flow editor libraries. Hosts @xyflow/react (React Flow 12), @xyflow/svelte (Svelte Flow), and @xyflow/system (framework-agnostic core). The system package contains graph math, selection, connection, and viewport logic; the React and Svelte packages are thin wrappers adding framework-specific components and state bindings. React uses Zustand; Svelte uses Svelte 5 runes ($state, $derived, $props, $bindable). Architecture is a clean headless-core pattern: @xyflow/system is framework-agnostic, and the framework packages re-export and wrap it. Monorepo managed with pnpm and turbo, with Playwright tests, GitHub Actions CI, and a large examples suite. Actively maintained with frequent releases. Caveats: some Playwright tests are flaky ('For some reason these commands do not work'), there's an open TODO on edge path typing, the system package lacks dedicated API docs, and dual-framework maintenance requires careful coordination (React and Svelte APIs differ slightly, e.g., multiSelectionKeyCode vs multiSelectionKey). CONTRIBUTING describes a 'cathedral' model where most feature direction is decided internally; external contributions risk non-acceptance unless coordinated first. Overall a high-quality, production-grade library. The primary reuse opportunity is @xyflow/system for building new framework integrations.
Understand Anything is a developer tool that analyzes codebases to create interactive knowledge graphs for code comprehension and onboarding. It combines deterministic static analysis (using tree-sitter) with LLM-powered semantic understanding to build explorable graphs of files, functions, classes, dependencies, and business domains. The system features a multi-agent pipeline for analysis, incremental updates via fingerprinting, and a React/Vite dashboard for visualization with guided tours, semantic search, and diff impact analysis. The architecture follows a monorepo structure with pnpm workspaces separating core analysis engine, dashboard UI, and plugin interface. Key capabilities include language-agnostic structural analysis across 30+ programming languages, business domain extraction, knowledge base analysis (Obsidian/Logseq-style wikis), and multi-platform support for AI coding assistants (Claude Code, Codex, Cursor, Copilot). The system operates offline for structural analysis while optionally leveraging LLMs for enrichment, with persistence to a .ua/ directory for team collaboration via version control.
Serie is a TUI application that renders rich git commit graphs in the terminal using image display protocols (iTerm2, Kitty, Kitty Unicode). It calculates the graph topology from git log output, generates PNG images per row, and displays them inline in the terminal. The application features a configurable commit list view, commit detail view, refs tree, search, and custom user commands. Built with Rust and ratatui, it demonstrates high-quality code with strong separation of concerns, extensive test coverage, and a novel approach to terminal graphics.
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.
ngx-graph is an Angular library for rendering directed acyclic graphs (DAG) and other graph structures using SVG. It provides a standalone GraphComponent with signal-based inputs and outputs, supporting multiple built-in layout engines (Dagre, DagreCluster, DagreNodesOnly, D3 force-directed, Cola force-directed) and custom layouts via a Layout interface. The component handles viewport transformations (pan, zoom), node dragging, minimap, and rich layout morph animations between graph updates. The architecture centers on a flexible layout service pattern where each layout is a class implementing run/updateEdge/hooks, and the GraphComponent orchestrates layout calculations, SVG rendering, and interaction. The codebase demonstrates modern Angular practices (signals, standalone components, OnPush change detection) and includes comprehensive test coverage. It is maintained by Swimlane with regular releases and extensive documentation via Storybook.
CodeGraph is a Python command-line tool that performs static analysis on Python source code to generate dependency graphs. It parses Python files to extract functions, classes, and import statements, then builds a graph showing how these entities depend on each other. The tool outputs an interactive HTML visualization (using D3.js by default) or can export the data to CSV or print it to the console. The architecture is modular, consisting of a parser (using Python's tokenize module), a core module that builds the dependency graph, utility functions for file discovery, and a visualizer that supports both D3.js (interactive) and matplotlib (legacy) backends. The tool does not execute the code being analyzed, making it safe and fast for large codebases. Key strengths include a robust parser that handles various import styles and class inheritance, and a flexible visualization system that provides features like search, collapsing/expanding nodes, and detailed tooltips. The project is actively maintained with comprehensive tests and supports multiple Python versions.
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.
This repository contains a Unity Editor tool for monitoring and visualizing PlayableGraphs in real-time. The tool displays the topology of PlayableGraphs showing nodes and connections, allows inspection of node details (playable properties, clip information, etc.), and provides UI controls for layout, refresh rate, and visibility options. It implements a modular architecture with separate concerns for the main window, graph view, node representations, object pooling, and utility functions. The tool supports various Playable node types with specific visualizations and handles edge cases like circular references in PlayableGraphs.
pydot is a pure Python library for creating, reading, editing, and rendering graphs in Graphviz's DOT language. It provides an object-oriented interface with classes like Graph, Node, Edge, Subgraph, and Cluster, allowing programmatic graph construction. The library can parse existing DOT files or strings into pydot objects, and render graphs to multiple output formats (PNG, SVG, PDF, etc.) by invoking external Graphviz executables. It depends on pyparsing for DOT parsing and on a separate Graphviz installation for rendering. The codebase demonstrates moderate craftsmanship with dynamic method generation for attributes and formats, an immutable FrozenDict class, and context manager support for nested graph building. However, it carries some technical debt: a vendored copy of CPython's tempfile module, incomplete type annotations, and a handful of long-standing known bugs (marked xfail in tests). The library is actively maintained with CI workflows across multiple Python versions and operating systems, but the dependency on an external binary and the vendored stdlib code are moderate risks.
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.