Get fluent in twenty minutes.

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

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

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.

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.

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

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

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.

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.

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

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 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.

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.

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 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 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 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 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 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 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.

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

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 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.

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.

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 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.

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.

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

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

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.

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

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.

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.

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.

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

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 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.

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.

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.

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.

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

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.

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

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.

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 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 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.

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.

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.

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 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.

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.

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 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.

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.

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 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 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.

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.

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.

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.

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.

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 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.

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.

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 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).

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 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.

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 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.

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 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 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 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.

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.

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.

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.