Projects sharing features with Go Diagrams

code2flow is a static program flow mapper and source code call graph generator. It analyzes source code to produce visual flow diagrams that map function call relationships and execution paths. The project includes an asynchronous call trace visualizer that follows execution paths through async and await calls to map the logic of asynchronous programs. It also provides a programmable code analysis interface, allowing the call graph generation logic to be integrated into other software applications. The system handles static code analysis by converting source code into abstract syntax trees t

GoJS is a JavaScript diagramming library and canvas-based visualization engine used to build interactive flowcharts, organizational charts, and network diagrams. It functions as a data-driven framework that binds JavaScript data models to visual elements, enabling bidirectional synchronization between the underlying data and the graphical representation. The library features a comprehensive graph layout engine capable of automatically arranging nodes into trees, grids, circles, or force-directed layouts. It distinguishes itself through a template-based system for generating visual parts and a

Kroki is a text-to-diagram rendering API and diagram-as-code server that transforms plain text definitions from various modeling languages into SVG or PNG images. It functions as a multi-language diagram renderer, providing a unified interface to generate flowcharts, UML diagrams, and charts using a collection of external libraries. The system utilizes a container-based plugin architecture and a sidecar rendering model to isolate external rendering engines. This design allows for the addition of new diagramming languages via companion containers and ensures stateless image generation where so

KubeDiagrams is a Kubernetes architecture visualizer and diagram generator that transforms manifests, Helm charts, and live cluster states into visual resource maps. It serves as a resource mapper that defines visual relationships between pods, services, and custom resources using labels and annotations. The system supports the resolution of templated charts and the mapping of custom resource types to specific visual representations via external configuration. It enables the addition of manual clusters, nodes, and edges to generated visuals through declarative extensions, and can export graph

viz-js is a JavaScript rendering library and graph visualization engine that converts Graphviz DOT language descriptions into visual diagrams. It functions as a Graphviz rendering library designed to produce SVG output for web applications. The project utilizes a WebAssembly port of the Graphviz C library to execute layout engines directly in the browser. To maintain interface responsiveness, it processes computationally expensive layout calculations within background worker threads and uses a standardized JSON format for layout serialization. The library provides tools for dynamic graph vis

js-sequence-diagrams is a JavaScript library used to generate SVG sequence diagrams from plain text descriptions. It functions as a text-to-diagram tool that transforms structured textual input into scalable vector graphics to represent system interaction flows. The library provides capabilities for system workflow visualization and technical documentation automation. It maps the communication between different components or services by converting text into visual representations of logic flows. The tool includes support for custom typeface loading to change the visual style and lettering of

Flowchart Fun is a text-based diagram generator and interactive visual canvas editor that automatically transforms plain text input and natural language prompts into structured flowcharts and diagrams without requiring manual node placement. The application combines automated layout algorithms and structural templates with a web canvas interface for organizing layouts, applying custom shapes, borders, colors, and text sizes to diagram nodes and edges. The platform includes multi-format export pipelines that convert finished charts directly into vector graphics, raster images, and document dat

Pencil is a cross-platform design environment and vector drawing application used for GUI prototyping and diagramming. It provides a canvas-based editor to create interactive user interface mockups, system architecture diagrams, and scalable visual representations of technical flows. The tool functions as a vector graphic editor that renders shapes as mathematical paths to ensure scalability across different resolutions. It includes a PDF export layout engine specifically designed to convert screen-based visual designs into fixed-layout documents for physical printing and distribution. The p

svgbob is an ASCII to SVG converter and text-based diagramming tool. It transforms structured ASCII diagrams and plain text sketches into clean, scalable vector graphics. The tool specializes in converting ASCII art and text-based scribbles into precise SVG paths, specifically for technical documentation and presentations. It supports the generation of directional arrows and structural diagrams by translating specific characters into vector lines, corners, and intersections. The system includes capabilities for rendering ASCII diagrams, generating vector graphics for technical guides, and es

Aspire is a .NET distributed application toolchain and cloud-native application orchestrator. It provides a code-first development stack for building, running, and deploying distributed applications, specifically managing the coordination of multiple services across different programming languages. The toolchain distinguishes itself through a programmable approach to service topologies, using a code-first methodology to define how services, containers, and databases interconnect. It manages the lifecycle of third-party containers as resources and translates these programmatic application mode

WireViz is a tool that generates wiring diagrams, bills of materials, and schematic routing from YAML configuration. It supports standard wire color codes such as IEC 60757 and DIN 47100, and automatically converts wire gauge units between square millimeters and American Wire Gauge (AWG). The tool automatically routes one-to-one wire connections within a harness by matching pin identifiers, eliminating manual layout steps. It also produces a bill of materials with wire lengths and part numbers directly from the same YAML input that defines the diagram.

This project is a technical reference and documentation suite focused on the internal architecture and operational principles of the Java Virtual Machine. It provides comprehensive guides and analysis on how the virtual machine manages class loading, memory organization, and bytecode execution. The documentation distinguishes itself by providing deep dives into specific runtime mechanisms, such as the binary decoding of class files, the hierarchical delegation model for class loaders, and the precise sequence of the loading, linking, and initialization lifecycle. It also details memory reclam

Fireworks Tech Graph is a tool that generates SVG and PNG technical diagrams from natural language descriptions, supporting both English and Chinese input. It produces publication-quality diagrams for AI architectures, UML types, and other technical domains without requiring manual drawing or diagramming syntax. The tool distinguishes itself through a semantic shape vocabulary and arrow-based flow encoding that conveys component roles and data flow types through consistent geometric shapes, stroke widths, dash patterns, and colors rather than relying on textual labels. It renders the same dia

Flowchart.js is a JavaScript library that converts a simple text-based domain-specific language into SVG flowcharts. It parses DSL keywords to define node types such as start, end, operation, condition, parallel, and subroutine, then renders them as distinct SVG shapes connected by directional paths. The library distinguishes itself through its styling and interactivity capabilities. It supports applying CSS classes to SVG elements for external stylesheet overrides, as well as inline attribute overrides for per-node and per-edge visual properties like fill, stroke, and font. Flowchart.js also

This project is a collection of standardized markdown layouts and component libraries used to organize project documentation, user profiles, and technical diagrams. It provides predefined templates for creating professional GitHub profile pages and structured documentation for open source projects, including guides for installation, usage, and contribution. The library features specialized templates for rendering flowcharts and sequence diagrams using text-to-visual syntax. It also includes a system for integrating dynamic profile statistics and status cards that automatically display user co

gprof2dot is a performance graph generator and visualizer that converts gprof GNU profiler execution profiles into Graphviz DOT files. It transforms raw profiler data into a directed graph to map function call hierarchies and identify software bottlenecks. The tool employs heuristic-based color mapping to highlight performance hotspots by assigning colors to nodes and edges based on execution time percentages. It also supports differential profile analysis, allowing for the comparison of two distinct execution graphs to identify changes in timing and call counts between runs. To improve visu

Spring-analysis is a diagnostic utility designed to visualize the internal architecture and execution logic of Java applications built on the Spring Framework. It functions as a static analysis tool that parses source code to map structural relationships and component interactions without requiring the program to execute. The tool distinguishes itself by automatically extracting configuration and annotation data to identify beans and service definitions, which it then translates into visual representations of the system. By reconstructing method call hierarchies and event propagation paths, i

This library is a finite state machine framework for JavaScript designed to manage application states and valid transitions. It provides a system for executing state changes with lifecycle hooks, conditional guards, and transition cancellation. The project is distinguished by its ability to inject state machine logic and transition capabilities directly into existing JavaScript class instances or objects. It also includes a visualization tool that exports state configurations into Graphviz DOT language for auditing system logic. The framework covers asynchronous transition execution and paus

Madge is a JavaScript module dependency visualizer and architecture mapper. It analyzes source code to create graphs and diagrams of module relationships, supporting CommonJS, AMD, and ES6 standards. The tool functions as a circular dependency detector to identify recursive import loops and a dependency graph generator that exports relationship maps into image and vector formats. It provides utilities for auditing project structure, including the identification of orphaned modules and leaf modules. Its broader capabilities include dead code identification, module impact analysis through depe

C4-PlantUML is a code-driven library that generates C4 model software architecture diagrams from PlantUML source text. It provides a set of reusable macros for creating system context, container, component, and deployment diagrams, enabling architects and developers to describe and communicate software architecture using the C4 model notation directly from diagram-as-code source files. The library distinguishes itself through hierarchical element nesting, which builds diagrams by nesting elements inside boundaries using PlantUML's rectangle and package constructs, and layout-direction control

Org-roam is an Emacs-based note-taking system that builds a bidirectional network of plain-text notes, functioning as a personal knowledge base manager. It maintains both forward and backlink references in a SQLite database, automatically updated on file save, and uses persistent unique identifiers for notes instead of file paths to enable stable links across renames and moves. The system integrates directly with Emacs through custom interactive commands and hooks that access the database and buffer state, and it generates static graphs of note interconnections using Graphviz to reveal relati

This project is a responsive Jekyll static site theme designed for technical blogs, documentation, and multilingual websites. It focuses on text readability and the presentation of technical content, providing a customizable CSS theme with multiple color palettes and dark mode toggling. The theme distinguishes itself through specialized rendering for technical assets, including mathematical formulas, diagrams, and syntax-highlighted code. It includes built-in internationalization support via translation keys to facilitate the creation of sites in multiple languages. The capability surface co

Doxygen is a source code documentation generator and multi-language API reference tool. It extracts annotated comments from source code to create structured technical manuals and searchable software libraries in formats including HTML, LaTeX, and PDF. The project functions as a static code analysis visualizer, generating call graphs, class diagrams, and inheritance hierarchies to illustrate codebase structure. It also serves as an XML documentation export engine, producing structured metadata that can be transformed via XSLT or third-party tools. Beyond API extraction, the tool provides a Ma

Vue Flow is a TypeScript library for building interactive node-based editors and flowcharts. It provides the core infrastructure for creating diagrams where users can drag, select, and connect nodes with edges, supporting pan and zoom navigation of the canvas. The library offers extensive control over graph behavior and appearance, including the ability to customize connection lines, define custom edge types, and configure zoom constraints and viewport defaults. It includes built-in components like a minimap for navigation, zoom controls, and a fit-view button, along with features for node re

Prompt patterns is a framework for organizing AI-driven system design through structured prompt engineering and domain-driven development methodologies. It provides a library of standardized interaction strategies designed to improve the consistency, accuracy, and logical reasoning of large language model outputs. By applying these patterns, users can translate complex business scenarios into structured domain models and technical specifications. The project distinguishes itself by integrating domain-driven design principles directly into the prompting workflow. It utilizes techniques such as

yn is a markdown text editor and knowledge management tool designed as an interactive document canvas. It functions as a networked note-taking system for organizing information via wiki-links, hashtags, and local file repositories, while integrating an AI writing assistant for automated text generation and completion. The project is distinguished by its multi-engine diagramming capabilities, which render text-based syntax into visuals using Mermaid, PlantUML, and ECharts. It employs an extensible plugin framework that allows for the addition of custom UI elements and features through JavaScri