Your files never leave your device. All processing happens locally in your browser.
How do I make a flowchart online for free without uploading anything?
Open the Flowchart Maker, click a shape in the palette (process, decision, terminator, input/output, data, document or connector) to drop it on the canvas, double‑click it to type a label, and drag it into place. Select a shape and drag one of its blue connection dots onto another shape to draw an arrow; click the arrow to label it Yes or No. Choose right‑angle elbow or straight routing, snap to the grid, then export a crisp PNG or an editable SVG, or save the chart as JSON — everything runs 100% in your browser and nothing is uploaded.
Seven typed flowchart shapes with editable fill, border, size and label
Drag a shape’s connection dot onto another shape to draw a directed arrow
Arrows re‑route live (orthogonal elbow or straight) as you move shapes
Snap‑to‑grid, pan, zoom, fit‑to‑view, duplicate, and z‑order (front / back)
Export PNG (2×) and editable SVG, plus JSON save / load / import — nothing uploaded
What is
Flowchart maker
A flowchart maker is a node‑and‑edge diagram editor for drawing process flows: you place typed SHAPES — a rectangle for a process step, a diamond for a decision, a rounded stadium for start/end (terminator), a parallelogram for input/output, plus data, document and connector symbols — and join them with directed ARROWS (connectors) that can carry labels such as Yes or No. A 100% client‑side flowchart maker holds the shapes and connectors as plain objects in the page, routes the arrows live from each shape’s current position, renders everything on an in‑browser SVG, and exports PNG / SVG / JSON on‑device, so nothing is uploaded.
No. Every shape and connector is a plain object held in the page and drawn on an in‑browser SVG; PNG export is a local canvas render, SVG and JSON are built in memory, and “Save” writes only to this browser’s localStorage. There is no server or CDN in the path.
The Flowchart Maker is 100% client‑side. Each shape carries a type, a label, an absolute x/y centre, a width, a height and fill/border colours, and each connector stores just its source id, target id and label — all small typed objects in the page. A pure engine (flowchartEngine.ts) routes the arrows and serialises the diagram. The chart you see is a live React <svg>; the PNG export serialises that same geometry to an SVG string (native <text>, no <foreignObject>) and draws it onto a local <canvas> with canvas.toBlob, the SVG export is that string saved as a file, and the JSON save is JSON.stringify of the shapes and connectors. “Save to this browser” uses localStorage on your own device only. Nothing is fetched, uploaded, logged or stored on a server, there is no CDN in the processing path, and fonts are your device’s system fonts so nothing is downloaded. The only optional network use is consent‑gated ads. It works offline once cached.
A rectangle is a process (an action or step), a diamond is a decision (a yes/no branch), a rounded stadium is a terminator (start or end), a parallelogram is input/output, a cylinder is stored data, a wavy sheet is a document, and a circle is an on‑page connector. These follow the common ANSI / ISO 5807 flowchart conventions.
The palette uses the standard flowchart symbols so your diagram reads the way people expect (the conventions codified by ANSI and ISO 5807). A RECTANGLE (process) is a single action or operation. A DIAMOND (decision) asks a question, and the arrow you follow out of it depends on the answer — label those arrows Yes and No. A rounded STADIUM (terminator) marks the Start or End of the flow. A PARALLELOGRAM is input/output — data a step needs or hands off. A CYLINDER represents stored DATA (a database or file). A wavy‑bottom sheet is a DOCUMENT. A small CIRCLE is a connector used to jump between parts of a large chart. Each shape is fully editable — rename it, recolour its fill and border, resize it, and change its stacking order — and connectors between them are drawn by dragging from a shape’s connection dot to another shape.
Straight connectors draw a direct line between the two shapes’ edges. Orthogonal (elbow) connectors use only right‑angle horizontal and vertical segments, meeting shapes on their nearest side — the tidy look used for most technical flowcharts. You can switch the whole chart between the two, and either way arrows re‑route as you move shapes.
Connectors are routed live from the current shape positions, so an arrow always updates the moment you drag either end. STRAIGHT routing draws a single line from the boundary of the source shape to the boundary of the target, pointing centre‑to‑centre — compact and good for simple links. ORTHOGONAL (elbow) routing uses only horizontal and vertical segments joined at right angles, leaving each shape from the side that faces the target and entering the target on the opposite side; this is the clean, technical look most flowcharts use and it keeps parallel arrows readable. The tool picks the exit/entry sides automatically from the relative positions of the two shapes and adds a mid‑line elbow. It is honest that this is a fast live router, not a collision‑free path‑finder: it does not steer arrows around other shapes, so if a link crosses a box you can nudge the shapes or switch routing mode.
Yes. Export a 2× PNG for sharing or an editable SVG for professional design tools / Illustrator / Inkscape, and save or download the chart as JSON to reload later or move it between devices. All exports are generated locally — nothing is uploaded.
You can export in three formats, all produced on‑device. PNG renders the exact geometry you see onto a local canvas at 2× on a white background — ideal for pasting into docs, slides or chat. SVG saves the chart as a clean vector with real shapes and <text> nodes, so you can keep editing it in professional design tools, Illustrator or Inkscape. JSON captures the full chart (every shape’s type, label, position, size and colours, plus every connector and its label); “Save” keeps it in this browser’s localStorage, “Download JSON” writes a file, and “Import” loads a JSON file back — the reliable way to move a chart between devices since there is no account or cloud sync. Because everything lives in memory (and optionally localStorage), export or save before you close the tab.
The Flowchart Maker is a 100% client-side diagramming tool — a free, private, watermark-free way to draw process flows as typed shapes joined by directed arrows. You drop shapes from a palette (process rectangle, decision diamond, terminator stadium, input/output parallelogram, data cylinder, document and connector circle), rename them in place, drag and resize them, recolour their fill and border, and connect them by dragging from a shape’s connection dot onto another shape. Connectors carry labels (Yes / No on a decision) and re-route live as you move shapes, in either right-angle elbow or straight style. The chart is drawn on an interactive in-browser SVG and exported on-device as a crisp PNG, an editable SVG, or a JSON file; nothing is ever uploaded.
Seven typed shapes following ANSI / ISO 5807 flowchart conventions
Draw directed connectors from a shape’s connection dot; label them Yes / No
Live orthogonal (elbow) or straight routing; snap-to-grid, pan, zoom, fit-to-view
Export 2× PNG, editable SVG and JSON — 100% in the browser, nothing uploaded
⚙️Methodology
Method: Typed Shapes, Absolute Geometry and Live Connector Routing
Each shape is a small typed object with a type, a label, an absolute x/y centre, a width, a height and fill/border colours, so dragging, resizing and snap-to-grid all reduce to overwriting those numbers. Each connector stores only a source id, a target id and a label; its path is recomputed every render from the two shapes’ current geometry, which is why arrows re-route automatically as shapes move. STRAIGHT routing draws a line between the shapes’ bounding-box boundaries pointing centre-to-centre. ORTHOGONAL routing chooses an exit side and an entry side from the relative positions of the shapes (horizontal when the horizontal gap dominates, vertical otherwise) and builds a right-angle elbow through a mid-line. Arrowheads are drawn as explicit filled triangles from the last segment’s direction so they rasterise reliably, and each shape’s outline is generated as an SVG path (rounded rect, diamond, stadium, parallelogram, cylinder with a top rim, wavy-bottom document, or circle) shared identically by the live render and the export.
Shapes carry absolute x/y + w/h — drag, resize and snap are number edits
Connectors store only source id, target id and label; paths recompute each render
Arrowheads are explicit filled triangles (reliable rasterisation)
One shape-path generator drives both the on-screen SVG and the export
🔧Technical Details
Rendering, Interaction and Export Internals
A pure engine (flowchartEngine.ts) is fully typed and browser-safe: it holds the shape and connector lists with immutable mutators (addNode, updateNode, removeNode, duplicateNode, reorderNode, addEdge, updateEdge, removeEdge), generates each shape’s path, wraps labels to the shape width, routes every connector, computes the union bounds for fit-to-view, and serialises the chart to JSON and to an SVG string. The page renders that model as a live React <svg> whose viewBox drives pan and zoom, aspect-locked to the container so screen pixels map linearly to SVG units for hit-testing and the inline rename overlay. Pointer events convert client coordinates into SVG coordinates via getBoundingClientRect; dragging a shape updates its centre (snapped to the grid when enabled), dragging empty canvas pans, a non-passive wheel listener zooms around the cursor, a corner handle resizes symmetrically about the centre, and dragging a connection dot onto another shape adds a connector. Export builds an SVG string that uses native <text> (deliberately no <foreignObject>, which many canvas rasterisers drop), so the same string both downloads as a vector and draws onto a local <canvas> at 2× for a PNG via canvas.toBlob.
Live React <svg> with a viewBox for pan / zoom; aspect locked to the container
Pointer→SVG mapping via getBoundingClientRect for drag, resize, pan and connect
Non-passive wheel listener zooms around the cursor; corner handle resizes from centre
Export SVG uses native <text> (no foreignObject) → rasterises cleanly to a 2× PNG
📋Use Cases
When to Reach for This
Use it to sketch a process, an algorithm, a decision tree, an onboarding or approval workflow, a data-flow or a runbook — quickly, privately and without an account, subscription or watermark. Start from the Simple process or Decision flow template, or from a blank canvas, then add typed shapes and wire them together; label the arrows out of a decision Yes and No so the branch reads at a glance. Export a PNG to drop into slides, docs or a chat, an SVG to keep refining in professional design tools, Illustrator or Inkscape, or JSON to save the chart and reopen it later or move it between devices. Because it is 100% local, it is a good fit for sensitive internal processes you would rather not upload to a cloud diagram service.
Great for process maps, algorithms, decision trees, approval / onboarding flows and runbooks
Start from a Simple process or Decision flow template, or a blank canvas
Label decision branches Yes / No for instantly readable logic
Export PNG for docs, SVG for editing, JSON to save and move between devices
Fully local — suitable for sensitive internal processes, no account needed
⚠️Limitations
Honest Limitations
This is a hand-drawn diagramming tool, not an auto-layout engine. You place and connect shapes yourself; there is no algorithm that arranges a diagram for you. The live connector router keeps arrows tidy as elbows or straight lines but does NOT do collision-free path-finding, so it will not steer a link around an intervening shape — if a connector crosses a box, nudge the shapes or switch routing mode. Arrows attach to the nearest side of a shape’s bounding box, so on a diamond or parallelogram they meet the box edge rather than the exact slanted vertex. Labels are wrapped from an ESTIMATE of text width using your device’s SYSTEM fonts, so a very long label can look tight and metrics can shift a hair between machines; the PNG is rendered on a white background from the same geometry, while the SVG stays fully editable. Saving keeps the chart in this browser’s localStorage only — there is no cloud sync or account — so use Export JSON to back it up or move it between devices, and export before closing the tab.
Hand-drawn tool: you place and connect shapes — no automatic layout
Live router is not collision-free — links can cross shapes; nudge or switch routing
Arrows meet the bounding-box edge, not the exact vertex of a diamond / parallelogram
Labels sized from an estimate with system fonts; metrics vary slightly between machines
localStorage-only save (no cloud / account); export JSON to move between devices
🔒Privacy & Security
Private by Design
Everything happens on your device. Each shape is a small object of a type, a label, a colour and a position/size, and each connector is a source id, a target id and a label; the engine routes the arrows and draws the chart on an in-browser SVG. The PNG export serialises that same geometry to an SVG string and draws it onto a local canvas with canvas.toBlob, the SVG export is that string saved as a file, and JSON save / download is JSON.stringify of the shapes and connectors — all produced locally. “Save to this browser” writes only to localStorage on your own device. There is no server and no CDN in the editing or export path, fonts are your device’s system fonts so nothing is fetched, and the only optional network use is consent-gated ads. The tool works offline once cached, keeps no accounts and sets no tracking; close the tab and unsaved work is gone.
Shapes and connectors are local objects drawn on an in-page SVG
PNG = local canvas.toBlob of the same geometry; SVG / JSON built in memory
“Save” writes only to this browser’s localStorage — no cloud, no account
No server or CDN in the path; system fonts only; optional consent-gated ads
Works offline once cached; unsaved work is discarded on tab close
Ways to make a flowchart
Approach
How it works
Trade-off
Used here
This client-side editor
Draw typed shapes on an in-browser SVG; live connector routing; export PNG / SVG / JSON
Private + free + no watermark; hand-drawn, no auto-layout
Yes
Cloud diagram tool (e.g. Lucidchart, Miro)
Charts stored and rendered on their servers with real-time collaboration
Collaboration and libraries, but uploads your work and often paywalls export
No
draw.io / diagrams.net
Free-form shapes and connectors, can run locally or in the cloud
Very capable and free, but heavier and less focused for a quick flowchart
Alternative
Pen and paper
Sketch boxes and arrows by hand
Fast and free, but not editable, shareable or exportable
No
Everything here runs in the browser; charts are never uploaded. Shapes follow ANSI / ISO 5807 conventions. As of July 2026.