Your files never leave your device. All processing happens locally in your browser.
How do I make a mind map online for free without uploading anything?
Open the Mind Map Generator, click the central node and press Tab to add a child branch or Enter to add a sibling, double‑click (or F2) to rename, and drag any node to reposition it. Give each branch its own colour, collapse a branch to focus, then hit “Tree” or “Radial” for one‑click auto‑layout and Fit to frame it. Export a crisp PNG or an editable SVG, or save the whole map as JSON — everything runs 100% in your browser and nothing is uploaded.
Tab = add child, Enter = add sibling, F2 / double‑click = rename, Delete = remove a node and its subtree
Free‑drag nodes anywhere, or one‑click radial / balanced‑tree auto‑layout
Colour‑coded branches, collapse / expand, pan, zoom and fit‑to‑view
Export PNG (2×) and editable SVG, plus JSON save / load / import
Rendered locally on an SVG canvas with system fonts — nothing is uploaded
What is
Mind map generator
A mind map generator is a visual outlining tool that arranges ideas as a tree of connected nodes: a central root idea in the middle with labelled branches radiating outward, each child linked to exactly one parent by a curved connector. You add, rename, recolour, drag and collapse nodes, and an auto‑layout can tidy the whole tree into a radial (concentric‑ring) or balanced left/right arrangement. A 100% client‑side generator holds the tree in memory, renders it on an in‑browser SVG, and exports PNG / SVG / JSON on‑device, so nothing is uploaded.
Design
Related terms
mind mapconcept mapbrainstormradial treenode editoroutlinespider diagrambranchroot nodeauto-layoutSVG export
Frequently Asked Questions
No. The whole map is a tree of plain objects 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 Mind Map Generator is 100% client‑side. Every node — its text, colour and x/y position — is a small typed object in a single tree held in the page, and a pure engine (mindMapEngine.ts) computes the layout and connector paths. The map you see is a live React <svg>; the PNG export serialises that same geometry to an SVG string (using 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 tree. “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.
Select a node, then Tab adds a child, Enter adds a sibling, F2 (or double‑click) renames, Space collapses or expands the branch, and Delete removes the node and its subtree. It matches the Tab‑child / Enter‑sibling convention used by MindMeister, XMind and Mind42.
The shortcuts follow the conventions of the best desktop mind mappers so muscle memory carries over. Click a node to select it (the canvas takes keyboard focus), then: Tab adds a child branch and immediately puts you in rename mode; Enter adds a sibling at the same level (also ready to rename); F2 or a double‑click renames the selected node in place; Space collapses or expands its branch; and Delete or Backspace removes the node together with its whole subtree. While you are typing a label, Enter commits and adds the next sibling and Tab commits and adds a child, so you can outline an entire map from the keyboard without reaching for the mouse. Escape deselects or cancels an edit.
Radial puts the root in the centre and fans every branch onto concentric rings by leaf count, like a spider diagram. Balanced tree splits the top‑level branches into left and right halves and stacks each side in tidy rows. Both overwrite node positions; you can still drag afterwards.
Radial layout places the root at the centre and distributes descendants around it: each leaf gets an equal angular slice of the full circle, an internal node sits at the midpoint of its descendants’ slice, and the radius grows one ring per level — the classic radial‑tree / spider look that shows the whole structure at a glance. Balanced tree layout keeps the root in the middle and divides its top‑level branches into a right group and a left group (balanced by how many leaves each carries), then lays each side out as a tidy horizontal tree where depth sets the column and children are stacked into rows with their parent centred on them. Auto‑layout is a one‑click tidy, not a constraint solver: it overwrites every node’s position, so you are free to fine‑tune by dragging afterwards, and Fit‑to‑view reframes the result.
Yes. Export a 2× PNG for sharing or an editable SVG for professional design tools / Illustrator / Inkscape, and save or download the map 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× scale on a white background — ideal for pasting into docs, slides or chat. SVG saves the map as a clean vector with real <text> nodes, so you can keep editing it in professional design tools, Illustrator or Inkscape. JSON captures the full tree (text, colours, positions and collapse state); “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 map 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.
Detailed Explanation
📖How It Works
Mind Map Generator — A Real, Private Node & Edge Editor
The Mind Map Generator is a 100% client-side visual outlining tool — a free, private, watermark-free way to brainstorm as a tree of connected ideas. A central root node sits in the middle and colour-coded branches radiate outward, each child linked to exactly one parent by a curved connector. You add children and siblings, rename nodes in place, drag them anywhere, recolour a whole branch and collapse a subtree to focus, then tidy everything with one-click radial or balanced-tree auto-layout. The map is drawn on an in-browser SVG and exported on-device as a crisp PNG, an editable SVG, or a JSON file; nothing is ever uploaded.
Tree model: a central root with colour-coded branches and curved parent-to-child connectors
Add child / sibling, rename in place, free-drag, recolour a branch, collapse / expand
One-click radial (concentric rings) or balanced left/right tree auto-layout
Pan, zoom, fit-to-view on an interactive SVG surface
Export 2× PNG, editable SVG and JSON — 100% in the browser, nothing uploaded
Every node stores an ABSOLUTE x/y, so free dragging and auto-layout coexist: a drag overwrites one node’s position while a layout overwrites the whole tree. The RADIAL layout is a classic radial tree — each leaf is given an equal angular slice of the full circle, an internal node is placed at the midpoint of its descendants’ combined slice, and the radius grows one ring per depth level. The BALANCED TREE layout keeps the root centred and splits its top-level branches into a right group and a left group weighted by leaf count, then lays each side out as a tidy horizontal tree where depth sets the column and a parent is centred on the vertical span of its children. Connectors are cubic-Bézier S-curves from parent centre to child centre, and per-branch colours are auto-assigned from a palette (brand teal / coral / gold first) and are fully editable.
Each node carries an absolute x/y — drag moves one node, layout rewrites the tree
Radial: equal angular slice per leaf, internal node at slice midpoint, one ring per level
Connectors are cubic-Bézier S-curves from parent to child
Branch colours auto-assigned (teal / coral / gold …) and editable per branch
🔧Technical Details
Rendering, Interaction and Export Internals
A pure engine (mindMapEngine.ts) is fully typed and browser-safe: it holds the tree, computes node widths from label length, flattens the visible nodes (respecting collapse), builds connector paths and the union bounds, and serialises the map to JSON and to an SVG string. The page renders that model as a live React <svg> whose viewBox drives pan and zoom, with the viewBox 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 node updates its x/y, dragging empty canvas pans, and a non-passive wheel listener zooms around the cursor. 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, pan and inline rename
Non-passive wheel listener zooms around the cursor position
Export SVG uses native <text> (no foreignObject) → rasterises cleanly to a 2× PNG
📋Use Cases
When to Reach for This
Use it to brainstorm, outline and organise ideas fast, privately and without an account, subscription or watermark: planning a project or essay, breaking down a goal into tasks, taking structured notes, running a solo brainstorm, or sketching a concept map or site outline. The Tab-child / Enter-sibling shortcuts (matching MindMeister, XMind and Mind42) let you type an entire map from the keyboard, then radial or tree auto-layout tidies it in one click. Export a PNG to drop into slides or docs, an SVG to keep refining in professional design tools or Illustrator, or JSON to save the map and reopen it later or move it between devices.
Great for project / essay planning, goal breakdowns, notes and concept maps
Type a whole map from the keyboard: Tab = child, Enter = sibling, F2 = rename
One-click radial or tree auto-layout, then fit-to-view
No account, subscription or watermark; works offline once cached
Export PNG for docs, SVG for editing, JSON to save and move between devices
⚠️Limitations
Honest Limitations
This is a visual brainstorming and outlining tool, not a full diagramming engine. Auto-layout produces a tidy radial or balanced-tree arrangement but does not do collision-free edge routing, so after a layout you may still nudge a few nodes by hand — free dragging and auto-layout are meant to be used together. The model is strictly a TREE: every node has exactly one parent, so there are no cross-links, loops or many-to-many relationships (use a flowchart tool for those). Node boxes are sized from an ESTIMATE of the label 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 map in this browser’s localStorage only — there is no cloud sync or account — so use Export JSON to move a map between devices, and export before closing the tab.
Brainstorming / outlining tool, not a full diagram engine with edge routing
Strictly a tree: one parent per node, no cross-links, loops or many-to-many
Node widths are estimated; system fonts mean metrics vary slightly between machines
PNG renders on a white background; SVG stays editable in professional design tools / Illustrator / Inkscape
localStorage-only save (no cloud / account); export JSON to move between devices
🔒Privacy & Security
Private by Design
Everything happens on your device. Each node is a small object of text, a colour and an x/y position in a single tree held in the page; the engine computes the layout and draws the map 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 tree — 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.
The map is a tree of 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 mind map
Approach
How it works
Trade-off
Used here
This client-side editor
Build a tree on an in-browser SVG; radial / tree auto-layout; export PNG / SVG / JSON
Private + free + no watermark; a tree, not a free-form diagram
Yes
Cloud mind mapper (e.g. MindMeister, Miro)
Maps stored and rendered on their servers with real-time collaboration
Collaboration and sync, but uploads your work and often paywalls export
No
Diagram tool (e.g. draw.io, Lucidchart)
Free-form shapes and connectors with manual or partial auto-layout
Cross-links and any topology, but heavier and less mind-map-focused
For non-tree diagrams
Pen and paper
Sketch nodes and branches by hand
Fast and free, but not editable, searchable or exportable
No
Everything here runs in the browser; maps are never uploaded. Tab = child and Enter = sibling match MindMeister / XMind / Mind42 conventions. As of July 2026.