Every engine, one studio.

Versatile text-to-diagram language. Renders flowcharts, sequence, class, ER, state, gantt, mindmap, sankey, C4, packet, architecture, kanban, radar, treemap, venn, wardley, eventmodeling and 30+ more. Paste any Mermaid snippet — fully compatible.

Pure UML + 20+ specialty diagrams: class, sequence, use-case, activity, state, component, deployment, object, timing, mindmap, WBS, gantt, salt, JSON, YAML, EBNF, regex, ditaa, AWS / Azure / GCP / K8s / Elastic architecture, Archimate, EIP, C4. Paste any PlantUML source — fully compatible.

Sketchy, hand-drawn UML-style diagrams from a small DSL. Perfect for whiteboard-style figures in talks and papers.

Lynn-Shostack-style service blueprints. Five lanes — physical evidence, customer journey, frontstage, backstage, support — with the canonical 'line of interaction / visibility / internal interaction' dividers. Native engine, pure SVG; line-based DSL means every step is diffable in git.

Full visual drag-and-drop canvas. Drag shapes from the palette, draw arrows between them, double-click to rename, move things around — exactly like Lucidchart, draw.io or Miro. The JSON source updates as you draw.

Concurrency's foundational model — places (circles) hold tokens, transitions (rectangles) fire when their inputs are saturated, arcs connect them. Tiny DSL: `place P1 tokens 2 "Ready"`, `transition T1 "fire"`, `P1 -> T1`. Auto-layout by topological depth, or pin every node with `@ x,y`. Native — no other major platform ships first-class Petri-net rendering.

Native finite state machines — cleaner than Mermaid's stateDiagram for serious modelling. Declare states (with optional `final` marker), an `initial` state (rendered with a lead-in dot), and transitions with `on` events, `[guards]`, and `/ actions`. Self-loops render as curved arrows above the state; final states get the canonical double-ring symbol.

Native cross-functional process diagrams. Declare lanes for each role / team, drop nodes into them, then draw edges. Columns are auto-assigned by longest-path topology, so every handoff between lanes is visually obvious. The clearest way to document a multi-team workflow.

Native Kanban boards for sprint planning, support queues, and operational dashboards. Declare `column` blocks with optional `wip` limits, then drop `card` lines with `assignee`, `priority`, and `tags`. Priority colours render as a left edge stripe; assignee initials show as a chip. Compact, print-friendly SVG.

Modern declarative architecture-diagram language. Concise syntax: `api -> db: queries` becomes an arrow with a label; `auth: { login -> session }` groups into a container. Renders through our Graphviz pipeline.

Workspace-based C4 architecture modelling. Define `softwareSystem`, `container`, `component` and `person` once, then declare multiple `views` (systemContext, container, deployment) over the same model. The canonical way to keep architecture documentation in sync across diagrams.

Industry-standard graph language. Excellent for DAGs, dependency graphs, finite automata, phylogenetic-style trees.

Text-based diagrams from the author of SQLite. Compact algebra of boxes, arrows, ovals, splines — perfect for documentation. Renders via Kroki, no install required.

Strategic value-chain × evolution mapping. Plot components on Visibility (y) × Evolution (x: Genesis / Custom / Product / Commodity), connect them by dependency. Native — no other major diagram platform handles this.

ASCII art → crisp SVG. Type boxes with dashes and pipes, arrows with `->`, diagonals with `\` and `/` — svgbob promotes them to real shapes. Perfect for inline documentation, README diagrams, code-comment figures that print as nicely as they read in a terminal.

Network topology diagrams from a tiny block-style DSL. Declare `network dmz { web1; web2 }` and edges are auto-routed across subnets, with IPs and labels rendered crisply. Renders via Kroki. The fastest way to sketch a corporate network or VPC layout.

Protocol packet layouts in a column-based DSL — write `0-15: source port` `16-31: destination port` and every bit-field renders with the correct width. Ideal for RFC-style protocol documentation; complementary to bytefield-svg.

ASCII-art → polished SVG, ditaa-style. Same idea as SVGBob but with native colour-fill markers — `cBLU`, `cRED`, `c1AB` — and dashed-line variants. Decades of muscle memory from technical writers will paste in unchanged.

Grammar of interactive graphics — scatter, line, bar, heatmap, box, violin, density, geo, layered & faceted scientific charts.

Lower-level visualization grammar: chord, sunburst, force-directed networks, treemaps, parallel coordinates, radar.

Publication-quality scientific plots: 3D surface, contour, ternary, polar, waterfall, ROC, Kaplan-Meier, dose-response, parallel coords, 40+ chart types.

Native squarified treemaps for hierarchical area visualization. Declare nodes with `parent` references and `size`; the engine sizes parents automatically as the sum of their children and uses the Bruls/Huijing/van Wijk squarified algorithm so every rectangle stays close to a 1:1 aspect ratio.

Native trapezoidal funnel charts for sales, growth, recruiting, and any multi-stage conversion. Each stage shows its absolute value and the conversion rate from the previous stage colour-coded (green ≥50 %, amber 20–50 %, red <20 %). Overall end-to-end conversion is printed below.

Native multi-stage Sankey flow diagrams for budgets, energy balances, conversion funnels, and traffic. Declare nodes + weighted flows; topological layout columns them by depth, ribbons are cubic-bezier filled paths whose thickness equals the value, and each node displays its total throughput.

Native music-theory diagrams. `type cycle` renders a two-ring cycle of fifths (majors outside, relative minors inside) with optional `highlight` chords filled. `type progression` lays out chord cards in a horizontal strip with Roman-numeral annotations — perfect for teaching ii–V–I, blues, and modal progressions.

Native choropleth maps for geography, demography, and epidemiology. Ships with a compact built-in atlas of world countries (ISO-3166 alpha-2) as a stylised hex-tile grid — no TopoJSON download required. Provide values per country code and the engine colour-scales them automatically. Bonus: a US states map (USPS codes) for state-level dashboards. Bigger atlas / SVG-accurate borders coming in a follow-up.

Database Markup Language — the lingua franca of relational schema design. Concise `Table users { id int [pk] name varchar }` syntax with explicit `Ref:` relationships, indexes, enums. Round-trips with dbdiagram.io exports — paste any DBML file and it renders.

Pure entity-relationship DSL. `[Person]` then `*name` for keys, `firstName` for fields, `Person *--1 Company {label: "works at"}` for relations. Renders through Graphviz internally, so layout is rock-solid even for 50-entity schemas. The cleanest text-to-ERD pipeline available.

Byte-field / packet-layout diagrams. Designed for binary protocol specifications, file-format documentation, network packet structure, register maps. Tiny Clojure-flavoured DSL — `(draw-column-headers)`, `(draw-box "flags" [{:span 4}])` — renders the kind of figure you see in RFCs.

Digital timing diagrams, register maps, bit fields and bus protocols. Standard for hardware and EE research.

Cable-harness diagrams for hardware engineering. Declare `connectors` and `cables` in YAML, list the `connections` between pin/wire pairs, and WireViz produces an annotated wiring schematic with conductor colours, pin labels, and a bill-of-materials. The first-class way to document any wiring loom — robotics, automotive, audio, lab rigs.

Render block symbols from VHDL / Verilog component declarations. Paste an entity or module header and get a neatly drawn symbol with grouped, aligned port pins — the kind of figure that lives in chip datasheets and FPGA documentation.

Native causal directed-acyclic graphs for epidemiology and inference. Declare nodes by role — `exposure`, `outcome`, `confounder`, `mediator`, `unobserved` — and the engine colour-codes them and lays out the diagram so the causal story reads left-to-right. Bidirected (`---`) edges render as dashed double-headed arcs for unmeasured association.

Native PRISMA 2020 systematic-review flow diagram — the standard for meta-analyses and literature reviews. Declare record counts at each stage (identification, screening, eligibility, included) and exclusion reasons; the engine renders the canonical four-section flow with excluded counts on the right.

Native genetics / genealogical pedigree charts using standard clinical notation: squares for males, circles for females, diamonds for unknown sex, filled symbols for affected individuals, half-filled for carriers, slashes for deceased, arrows for the proband. Mating lines link partners, sibship lines descend to children.

Native argument maps for philosophy, critical thinking, debate, and legal reasoning. Declare a central `claim`, then `support` and `object` arguments either attacking the claim or rebutting other arguments. PRO arguments render green, CON arguments red, with arrows pointing FROM each argument TO whatever it supports or attacks. Rebuttals nest naturally.

Native root-cause analysis. Declare a `problem`, then `category` / `cause` blocks; the backbone, ribs, and cause branches render as crisp SVG. Categories alternate above and below the backbone, automatically scaled to fit. The standard tool for 5-Whys, Six Sigma, and incident reviews.

Native Venn and Euler diagrams for 1, 2, or 3 sets. Declare `set`, then label each region with `only` or `intersect`. Stacked labels per region. Perfect for showing overlapping responsibilities, audience segments, or skill matrices.

Native free-body diagrams for mechanical, structural, and civil engineering. Declare bodies with `at x,y` positions and arbitrary force vectors with magnitudes, colours, and labels. Supports `moment` curved-arrow torques and an optional hatched `surface` line for incline / floor contexts. Renders in a true coordinate system so vectors are physically faithful.

Native process & instrumentation diagrams for chemical engineering. Declare equipment (vessel, reactor, heat-exchanger, pump, compressor, tank, column, separator), instruments (gauges + control loops in ISA-5.1-style balloons), and piping connections between them. Supports stream tags, valves (gate, ball, check, control), and tagged process variables (PV, FV, LV, TV).

Native phase diagrams for materials science and thermodynamics. `type pt` (pressure × temperature) renders single-component diagrams with sublimation / vaporisation / fusion curves and labelled triple / critical points. `type binary` renders a composition × temperature alloy diagram with liquidus + solidus curves bridging both pure-component melting points.

Native electrical schematic capture. Declare components (resistor, capacitor, inductor, diode, LED, transistor, op-amp, source, ground, switch, junction) at grid coordinates with values, then wire them together. Renders with standard IEC / ANSI-style symbols and labelled values. Ideal for textbook circuits, lab notes, and small-design documentation; not a substitute for KiCad on a real PCB.

Native top-down architectural floor plans. Declare walls as coordinate pairs, drop doors (with arc) and windows (double-line), label rooms with optional areas, and place furniture from a built-in library (sofa, bed, table, fridge, stove, sink, toilet, shower, bathtub, desk, tv, plant). Renders crisp printable SVG with an optional dot grid and scale bar.

Same DSL as Floor plan (2D), rendered in axonometric / isometric SVG with extruded walls — a printable 3D view, no WebGL. Pick `view iso | front | side | top` and set the wall `height`. This is intentionally a viewer (not an editable SketchUp / Revit-style modeller); for diagram, deck, and PDF use-cases an axonometric SVG covers 80 % of the use case at 5 % of the engineering cost.

Native project network diagrams with the critical path highlighted. Declare tasks with `duration` and `after`; the engine runs the full forward + backward pass and renders ES / EF / LS / LF / slack in every node. Zero-slack tasks are flagged as CRITICAL in amber.

Native attack-tree diagrams for threat modelling and security review. Declare a root goal, then sub-goals as AND (all-of) or OR (any-of) refinements. Leaf nodes carry cost / skill / detection estimates that propagate up the tree. Critical paths render in red. Compatible with STRIDE / DREAD workflows.

Native pharmacology / clinical-pharmacy network diagrams. Declare drugs (with optional therapeutic class) and pairwise interactions with effect, severity, and mechanism. Edges are colour-coded by severity (minor → moderate → major → contraindicated) and stack cleanly when one drug pair has multiple interactions. Ideal for polypharmacy reviews and pharmacology teaching.

Native constituency / parse trees for linguistics and NLP teaching. Accepts both Penn Treebank parenthesised notation `(S (NP (DT The) (NN cat)) (VP (V sat)))` and a 2-space indented form. Non-terminals render bold; leaf terminals render italic in a classic serif face. Auto-laid-out so each node sits centred over its children.

Native stratigraphic columns for geology and archaeology + Harris matrix for relative chronology. `type column` renders layers with thickness, colour, age labels, and depth ticks. `type harris` lays out context units in a DAG with `above` relationships, auto-levelling so each unit sits above whatever it physically overlies.

Interactive 3D molecular visualization: proteins from PDB, ligands, surfaces, cartoons. WebGL-powered.

Phylogenetic trees in Newick format with branch lengths and bootstrap support. Renders cladograms / phylograms.

Mathematical typesetting: equations, derivations, matrices, commutative diagrams. Renders LaTeX math in the browser.

Native anatomy diagrams for medicine, nursing, and biology teaching. Pick a body diagram (`whole`, `heart`, `lungs`, `kidney`, `brain`, `digestive`, `skeleton`) and drop labelled markers at specific anatomical points. Markers come with leader lines and an optional callout box so a single diagram supports both lecture annotations and exam-style labelling sheets.

Native single-voice music notation. Parses a minimal ABC-style syntax (note letters with optional accidentals, durations, bar lines) and engraves it on a treble or bass clef with key signature, time signature, and a basic note / rest set (whole, half, quarter, eighth, sixteenth). Suitable for music theory teaching, melody jotting, and lecture slides; not a full engraver — chords, beams, slurs, and complex articulations will come in a follow-up.

Native piano-roll melody visualization. Notes render as coloured rectangles on a horizontal time axis with a full piano keyboard on the left (white + black keys). Supports tempo / time signature / per-note colour + velocity. Complements the ABC-style `music` engine for melodic snippets.

Chess positions from Forsyth–Edwards Notation. Paste any FEN — from Lichess, chess.com, PGN headers — and get a print-quality board with Unicode pieces, file/rank labels, and an optional side-to-move pip. Stack multiple FENs separated by blank lines for opening sequences or tactical puzzles.

Native single-elimination tournament brackets. Teams + matches declared as flat data; the engine infers rounds from match-dependency depth and lays out cards in columns with connectors between rounds. Winners are highlighted in amber; scores render right-aligned per team.

Native astronomy diagrams. Pick `type orbital` for a Sun-centred orbital map (planets sized + tinted by parameters, distance in AU) or `type hr` for a Hertzsprung-Russell diagram with logarithmic temperature × luminosity axes, a main-sequence shading band, and star markers coloured by stellar class.

Native digital-logic engine — three modes in one. `type gates` for IEC-style gate schematics (AND, OR, NOT, NAND, NOR, XOR, XNOR, BUF), `type kmap` for 2-4 variable Karnaugh maps with Gray-coded rows / columns and highlighted 1-cells, `type truthtable` for full truth tables with output-coloured cells. Covers the EE / CS undergraduate digital-logic curriculum.

Native Forrester-style system-dynamics diagrams. Stocks render as rectangles, flows as double-line pipes with valves, clouds as source/sink shapes, auxiliaries as circles, and information links as dashed arrows. Used for ecology, economics, public health, and any dynamic systems modelling.

Native historical / era timelines. Declare an axis with start and end years, drop labelled `event` points at specific dates, draw `era` bands spanning ranges (Bronze Age, Renaissance, Cold War), and stack lanes for parallel narratives (e.g. politics vs. science). Renders with smart label dodging so dense periods stay readable. Distinct from Gantt — built for centuries and millennia, not sprint days.

The first diagram language designed for research. Every element has a domain type — `study`, `cohort`, `arm`, `outcome`, `project`, `task`, `service`, `kpi`, … — and numbers PROPAGATE. Declare `cohort eligible { n: 1240, from: screened, excluded: { ineligible: 198, declined: 64 } }` and the validator checks that 198 + 64 + 1240 = screened.n. One model renders as many publication-ready views (CONSORT 2010 flow ships in V0; Sankey, summary-bars, Gantt, C4, funnel coming next). Designed for clinical trials, biology, ML eval, project management, engineering architecture, and business strategy from day one.

Render hierarchical mindmaps directly from Markdown bullet lists. Great for outlines and concept hierarchies.

Hand-tuned SVG for custom scientific schematics: circuits, optics, anatomy, geological cross-sections.

Business Process Model and Notation 2.0 — gateways, pools, events, tasks. Standard for process modelling in industry and operations research.

Biological / knowledge networks with force-directed, circular, breadth-first layouts. Edge styling, node colouring, large-graph rendering.

Hand-drawn whiteboard aesthetic for real. Drop in an Excalidraw `.excalidraw` JSON export (or compose one inline) and render it as a publication-ready SVG with the signature rough-pen feel. Round-trips with excalidraw.com — paste anything you sketched there.

Native bullet graphs (Stephen Few) for KPI dashboards. Each `metric` has a value, an optional target tick, a max, and ascending qualitative range bands (poor / ok / good). A compact, ink-efficient replacement for gauges and speedometers.

Native GitHub-contributions-style calendar heatmap. Give a year and `YYYY-MM-DD value` rows; days render as a 7×53 grid shaded by value with month and weekday labels and a legend. Ideal for activity, habits and daily time-series.

Native economics teaching diagrams. Pick a diagram type (`supply-demand`, `is-lm`, `phillips`, `production-possibility`, `payoff-matrix`, `lorenz`) and provide the curves' shifts and labels. Renders with proper axis labels, intersection annotations, shaded surplus regions, and payoff cells for game-theory matrices.

Native flame graphs from folded-stack input (semicolon-separated frames + a sample count). Frame width is proportional to total samples and depth grows upward, coloured warm by frame. The standard tool for CPU / performance profiling.

Real-time 3D viewer for floor plans, rendered with Three.js. Same DSL as the 2D / axonometric floor-plan engines — walls extrude up, rooms become 3D volumes, and you can orbit / pan / zoom with the mouse or pinch on touch. This is Phase 1 of the editable architecture modeller; phase 2 will add raycaster click-to-edit on walls, doors, and furniture so you can model interactively while the DSL stays the source of truth.

Native Marimekko (mosaic) charts. Each `column` has a weight (its width) and stacked segments (their heights as a share of the column). Segments with the same label share a colour across columns, with a legend. For market structure, share × volume and two-dimensional proportions.

Native organisational charts from an indentation-based outline. One person or unit per line — `Name | Role | meta` — with 2-space indents for reporting lines. Auto-laid-out top-down tree of rounded cards with elbow connectors, depth-tinted accents, optional role and metadata rows (team size, location), and multiple roots for holding structures. The org chart Graphviz makes you fight for, in ten lines of text.

Native 2×2 decision matrices and quadrant charts — Eisenhower, BCG growth-share, risk (likelihood × impact), effort/impact prioritisation, Gartner-style magic quadrants, stakeholder power/interest, and SWOT-as-scatter. Declare two axes, four quadrant labels, and `point` rows at 0..1 coordinates; points inherit their quadrant's accent or take an explicit `#hex`. Mermaid-quadrantChart-compatible syntax, rendered as crisp print-ready SVG.

Native RACI / RASCI responsibility-assignment matrices. Declare columns with `roles: PM, Design, Eng`, then one task per line — `Launch approval | A, I, R` — using R / A / S / C / I codes, combinations like `A/R`, and `-` for none (case-insensitive, extra or missing cells forgiven). Renders a zebra-striped matrix of colour-coded chips with a role header and a compact legend. The who-does-what chart every project kickoff rebuilds in a spreadsheet.

Native data-centre rack elevations. Set the rack height in `units` (U) and place each `device` at a top U with a height; the numbered rack frame, empty slots and labelled equipment render as crisp SVG. For IT infrastructure and capacity planning.

Native railroad (syntax) diagrams for grammars, json.org style. One production per block — `rule ::= term | other` — with sequences, stacked `|` choices, `[optional]` bypasses, `{repetition}` loops and `(grouping)`. Quoted terminals render as rounded pills, bare nonterminals as rectangles, and every rule in the document renders as its own stacked diagram. The standard way language and API docs explain syntax.

Native waterfall (bridge) charts. Declare an absolute `bar`, floating `delta` steps (+/-), and computed `total` bars; increases render green, decreases red, anchors blue, with dashed connectors and a value axis. The standard view for revenue bridges, variance analysis and budget walks.

Native word / tag cloud. List terms one per line with an optional trailing weight; terms are sized by weight and packed into balanced centred rows with a rotating colour palette. Great for themes, keywords, survey free-text, and brainstorm summaries.