A language for
every idea.

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.

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, and the only engine here that decides whether the machine is one. A state machine's defects are facts about reachability and determinism, and neither has pixels: two arrows leaving a state on the same event with nothing to tell them apart is a machine and a coin toss, and it draws as two perfectly ordinary arrows. The engine reports nondeterministic branching, states nothing can reach, non-final states with no way out, a machine that can never terminate, and transitions naming states that were never declared — which every tool that draws what it is handed simply omits from the figure. Every arrow the document writes is drawn, and none is drawn through a box.

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.

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

DMN 1.4 decision requirement diagrams and decision tables, with every hit policy and — the point of the engine — a real check of the table's input space: which rules can both fire, and which inputs no rule answers. A column with no declared domain is reported as undecidable rather than quietly assumed complete.

UML sequence diagrams CHECKED against the call stack they describe, not merely drawn. Every arrow is drawn where it was typed, so what makes an interaction wrong leaves almost nothing behind in the picture: a reply returned to the wrong participant moves one arrowhead one column and changes three of the figure's ninety-five elements, and a reader who sees a reply come back reads it as a reply coming back. A message to a destroyed lifeline and a deadlock leave nothing at all. This engine decides seventeen questions the drawing cannot show: a reply returned to a participant that never made the call, a message to a lifeline after its destruction cross, a call answered on only one branch of an `alt`, a cycle of calls none of which can be answered, two concurrent branches racing to address one service, two `alt` guards that both accept the same input, and a band of inputs no branch handles. Messages state whether they are a call, a reply or a fire-and-forget, because an arrowhead does not — and a document imported from a notation that leaves that unstated is reported as unchecked rather than analysed on a guess.

Native value-stream maps (VSM) for lean process analysis. Declare process boxes with their data — `process Weld { ct: 45s; co: 30m; uptime: 85%; operators: 2 }` — and the inventory or wait time between them, and the engine draws the timeline ladder and COMPUTES what the map exists to show: total lead time, total value-added time, flow efficiency, and the takt comparison. The one process diagram whose numbers are an analysis rather than a caption.

Cumulative flow diagrams with the flow metrics derived from the same data. Give it a date column and one cumulative count per workflow stage and it draws the stacked bands, then computes approximate WIP, average cycle time via Little's Law, throughput and flow efficiency, and marks where WIP ran away from throughput. The chart Kanban teams screenshot, with the four numbers they actually manage against.

Structured-analysis data flow diagrams in the Gane–Sarson notation: external entities, numbered processes, data stores and labelled flows, at any level (context diagram through level 2+). Trust boundaries are first-class, which makes the same figure a STRIDE threat model. Balance checking catches the classic defects — a store that is only ever read, a process with input and no output (a black hole) or output and no input (a miracle).

The Six Sigma scoping diagram — Suppliers, Inputs, Process, Outputs, Customers — as five aligned columns with the process steps as a spine across the middle. Optional `requirements:` rows attach CTQ criteria to inputs and outputs, so the chart that usually says what a process touches also says what 'good' means for each one. The first artefact of every DMAIC define phase.

Reliability block diagrams with the reliability actually computed: series, parallel, k-out-of-n and standby arrangements over blocks carrying R, MTBF or failure rate, evaluated to system reliability, MTTF and availability at a chosen mission time. Redundancy that buys nothing shows up as a branch that moves the system number by a rounding error — which is the entire point of drawing one.

Statistical process control charts — I-MR, X̄-R, X̄-S, p, np, c and u — with the centre line and control limits computed from the data by the standard unbiasing constants (d2, d3, c4, A2, A3, B3, B4, D3, D4), never typed in. All eight Nelson rules run over the plotted series and every violation is marked and listed, and process capability (Cp, Cpk, Pp, Ppk) is computed when specification limits are given. A chart whose limits were guessed is not a control chart.

The 80/20 chart, computed: sorted bars with the cumulative percentage curve on a second axis, the 80% reference line, and the vital-few cut marked where the curve crosses it. Categories are ranked and any tail can be folded into an explicit `Other` bar rather than silently dropped, and a second period can be overlaid to show whether last quarter's vital few are still this quarter's.

Dependency structure matrices for architecture and process analysis. Declare elements and their dependencies and the engine renders the square matrix, then does the analysis a picture cannot: partitioning into a sequenced, block-triangular order, detection of the cyclic blocks that must be iterated, and counts of the feedback marks above the diagonal that quantify how much rework the current sequence forces.

Quantitative fault-tree analysis in the IEC 61025 notation. Build the tree from AND / OR / k-out-of-n / INHIBIT gates over basic events carrying probabilities, and the engine computes the top-event probability exactly rather than by the rare-event approximation, ranks each basic event's Birnbaum and Fussell-Vesely importance, and enumerates the minimal cut sets. The safety analysis a boxes-and-lines drawing cannot perform.

The barrier-based risk diagram used in process safety, aviation and healthcare: threats on the left, the top event at the knot, consequences on the right, and preventive and recovery barriers on every path — each with its own effectiveness, escalation factors and degradation controls. Residual risk per path is computed from the barrier chain, so a decorative barrier is visible as one that changes no number.

Decision analysis with the rollback computed: decision squares, chance circles and outcome triangles, expected values rolled back from the payoffs and printed on every node, the optimal choice marked at every decision and rejected alternatives struck through. Probabilities under every chance node are validated to sum to 1 (`p rest` takes the complement), branch costs are charged on the way through, and an optional risk profile, a cumulative comparison of first choices, a stochastic-dominance check and exponential-utility certainty equivalents show what the expected value hides. Payoffs can be money, QALYs, or costs to minimise.

A risk register and its heat map, scored rather than coloured by hand. Rate each risk on likelihood and impact (1–5 or named levels, 2–7 levels per axis), list its controls, residual and target positions, owner and actions, and the engine computes L×I scores and band ratings. It draws the matrix with risk ids in their cells and arrows from inherent to residual. It sorts the register, totals exposure and its reduction, and flags risks above appetite. Bands are configurable (thresholds, named ranges or a cell-by-cell matrix such as the ICAO tolerability matrix). The validator reports a residual worse than the inherent rating, a reduction no control explains, a risk with no owner, and a band that leaves a score unrated.

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.

Queueing networks solved, not merely drawn. Declare stations with arrival and service rates and server counts — M/M/1, M/M/c, M/M/c/K and M/G/1 are all supported — wire them with routing probabilities, and the engine solves the traffic equations and reports utilisation, mean queue length, waiting time and sojourn time per station plus the end-to-end response time, flagging any station whose utilisation reaches one as the bottleneck that makes the whole network unstable.

The lean motion study: place stations on a floor plan, trace the path a person, patient or part actually takes, and the engine measures it — total travel distance, per-leg distances, revisit counts and the crossings that mark a layout fighting its own flow. Multiple traced actors overlay in distinct colours so a before/after layout change is one figure, with the metres saved computed rather than claimed.

The Osterwalder Business Model Canvas and Ash Maurya's Lean Canvas from one nine-block syntax — `layout: lean` switches the grid and the block names. Notes carry optional confidence marks, so the canvas shows which blocks are still guesses, and the cost/revenue strip totals any figures you put in it. The strategy one-pager every deck rebuilds by hand.

Weighted decision matrices and Pugh concept selection, with the arithmetic done for you. Weights are normalised and checked (two levels with groups) and scores can use any scale. Measured criteria such as cost or latency are rescaled onto that scale, and must-have knock-outs exclude an option whatever its total. You get totals, a ranking and a highlighted winner, plus the question a steering committee actually asks: how far would one weight have to move before the answer changed? It is answered for every challenger, alongside dominated options and criteria that separate nothing. Write +/S/− against a datum and the same notation becomes a Pugh matrix with Σ+, ΣS, Σ− and a weighted net.

IEC 61131-3 ladder diagrams: rungs of normally-open and normally-closed contacts, coils, set/reset latches, timers (TON/TOF/TP) and counters (CTU/CTD), drawn between the power rails with parallel branches for OR logic. The engine evaluates each rung against a declared input state, so the drawing can show which rungs are true — the industrial control diagram nothing else in a diagram tool renders.

IEC 60848 GRAFCET and IEC 61131-3 sequential function charts: numbered steps with their actions, transitions with their receptivities, and the divergences and convergences — both alternative (OR) and simultaneous (AND) — drawn with the correct single and double bars. Initial steps get their double border, and the engine checks the well-formedness rule every hand-drawn SFC violates: steps and transitions must strictly alternate.

Project schedules COMPUTED from durations, dependencies and a working calendar — never placed by hand. Forward and backward pass for the critical path, total and free float drawn as a whisker on every bar, all four precedence relationships (FS, SS, FF, SF) with lead and lag, calendar-day durations for waiting periods, resources and over-allocation, baselines and deadlines. Every date written in the document is treated as a claim and checked against the computation: a stated start that its own predecessors contradict, a missed deadline, one person booked on two overlapping tasks, and a dependency loop that has no schedule at all. `view network` draws the same schedule as an activity-on-node precedence network instead of bars — one document, two views, one computation, so they cannot disagree.

Product, technology and programme roadmaps whose arrows are CHECKED against their dates. Lanes for themes or teams; items placed by quarter, month, half, year or on a Now / Next / Later horizon; four statuses (planned, in progress, done, at risk), each with a symbol as well as a colour so the figure survives greyscale; milestones on a band of their own with guide lines, or inside a lane; and a status date that draws the today line. Every dependency is checked: a prerequisite still running when its dependent starts is drawn red and named with the overlap in days, a loop or an unknown prerequisite is an error, and with a status date the engine reports what is overdue and anything marked done or in progress before it was due to start.

Alberto Brandolini's event-storming board in its canonical colours: orange domain events on a timeline, blue commands, yellow actors, purple policies, pink external systems, green read models and lilac aggregates — with hotspots called out in red. Swimlanes group by bounded context, and the engine flags the shapes DDD says are suspect: an event no command produces, a command with no aggregate, an aggregate with no events.

Jeff Patton style user story maps: the activity backbone across the top, user tasks beneath it, and stories sliced into horizontal releases. Estimates roll up per release and per column, so the walking skeleton is visibly the smallest slice that spans the backbone rather than an assertion in a caption. The planning artefact a flat backlog throws away.

Customer and user journey maps with the arithmetic done: stages as columns with rows for goals, actions, touchpoints, thoughts, pain points, opportunities and owners/metrics, a persona card, and an emotion curve scored −2…+2 across the stages with a face on every stage. The engine computes the moment of truth (the lowest-scored stage, ties named), the peak, the pain points per stage, the sharpest drop and the average, and flags stages that carry pain points with no opportunity against them.

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.

Native data-centre rack elevations, and the only one that checks whether the rack can actually be built. Set the height in `units` and place each `device` at a top U with a height, optionally with its `power` and `weight`; the engine reports two devices claiming the same unit (drawn one over the other, so the figure shows one where the document declares two), any device that reaches past either end of the rack (silently clamped by every tool that draws what it is handed), free capacity and the tallest device that would still fit, and the declared draw and mass against the rack's stated budgets.

ArchiMate 3.2 enterprise architecture: business, application, technology, motivation, strategy and migration layers, with all eleven relationships drawn to the specification's own line styles and end decorations. The layer is derived from the element type rather than declared beside it, so the band and the colour cannot disagree.

Cloud and platform architecture across AWS, Azure, Google Cloud and Kubernetes — 331 resource types, real containment (account, region, network, zone, subnet, cluster, namespace) and typed edges. Checks the architecture as well as drawing it: a datastore reachable from the internet with no ingress on the path, a datastore in a public subnet, a tier claiming redundancy from inside one zone, an edge crossing a network boundary with no gateway.

Model-based systems engineering in the OMG SysML v2 textual notation — parts, ports, interfaces, item flows, specialization and redefinition — drawn as an interconnection view and a decomposition, and CHECKED. An internal block diagram hides everything that decides whether a system can actually be wired: a port's directions live in another box on another page, its conjugation is a single `~`, an interface's end order appears nowhere on the page at all. Delete one tilde from a correct fuel system and the figure is pixel-identical while every direction reverses. This engine decides thirteen questions the picture cannot show — two ports that both supply and never consume, an interface bound the wrong way round, a flow carrying a payload its destination does not accept, a redefinition that misspelt what it replaces and silently declared a second feature beside it, a composition cycle no instance of which can be built — and it distinguishes a defect in the model from a library it does not carry, so `import ISQ::*` produces gaps rather than forty false errors.

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.

Plain XY charts and plotted functions: scatter, line, grouped bars, histograms with a named bin rule, Tukey boxes, and formulas sampled adaptively so a high-frequency curve is not quietly aliased into a different one. Renders natively, so it works offline and on the server.

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.

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

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

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

Protocol headers and register bit-field layouts at 8, 16, 32 or 64 bits a word, in either bit order and saying which is in force. Checks the layout rather than just drawing it: overlapping fields, unclaimed bit runs and fields that overflow the declared extent are computed and named.

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 — and the only one that checks the arithmetic the standard is made of. A PRISMA figure exists so that every record entering a review is accounted for on its way out, which makes it an arithmetic claim: the engine balances all four stages (identification, screening, retrieval, eligibility), reports the exact count of records that vanished and where, draws the failing stage's arrow in red, and marks a stage it could not balance as a gap naming the missing term rather than passing it.

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 a single-component diagram with SCHEMATIC sublimation / vaporisation / fusion curves and labelled triple and critical points — the curve shapes are qualitative and identical for every substance; the declared temperatures and pressures set the point markers and their captions, not the paths between them. `type binary` renders a composition × temperature alloy diagram against a numeric temperature axis read from the two declared melting points, with schematic liquidus and solidus curves bridging them.

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.

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 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. Finish-to-start only, in whole unit-less days — for a schedule on a real working calendar, with start-to-start, finish-to-finish and start-to-finish relationships, lead and lag, resources, deadlines and the compression ranking, use `gantt`, which draws the same network under `view network` from a schedule it also draws as bars.

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.