The product

A reader for the structure you already wrote.

md2hd is one screen: a rail of maps, a canvas, and a panel. It parses markdown in the browser and draws what it finds. There is no import step that transforms your notes into something else, and no format you have to keep in sync.

The full md2hd canvas showing the Partnerships sample map: ten cards in five colours connected by labelled links, with a rail of maps on the left and a breadcrumb of the map's types along the top. — The Partnerships sample, as it opens. Colour is the node's type; the strength of the stroke is its weight.

Focus

The map re-forms around what you clicked.

Selecting a node lays out its ego network — incoming on the left, outgoing on the right, itself in the middle — which has no crossings by construction. The panel opens alongside with the note, every field, and both wordings of every connection.

A node selected in md2hd: the map has re-laid itself around it, and the detail panel on the right shows the note, its fields and its connections. — Click the background and the full map returns exactly as you arranged it. Ego placement is never saved.

Three surfaces

map ▸ type ▸node, and a breadcrumb for the lift.

Clicking a node answers "what is this?" but never "what else is like it?" or "what is in here?" — questions a map raises constantly. So the panel is three surfaces of one hierarchy rather than a detail view with a second list bolted on.

The type surface in md2hd: the breadcrumb reads Partnerships then Programs, the two program nodes stand forward on the canvas while everything else recedes, and the panel lists them above a config dock. — The type surface. Every node of that type itemised, with the config dock for what its cards draw anchored under the list.

The trail is the navigation: Each surface renders its own ancestors, so no surface has to remember where you came from and there is no back stack to get wrong.
The strip selects, it does not hide: The chips along the canvas are the map's own breadcrumb. Hiding a type is a toggle in that type's dock, and a hidden type stays in the strip, struck through.
Artifacts are scoped, and the map wins: Type, link count, subtitle and tags are configurable per type. Off anywhere means off: the map can silence one everywhere, a type can only turn its own off. The overruled chip is left visible and disabled so the reason is legible.

Editing

The canvas is for reading.

The panel's second tab is the file the node came from, as text, full height. The map redraws as you type — retitle a node and watch the card change, add arel: and watch the line appear.

The md2hd detail panel showing the Source tab: the raw markdown of the file the selected node came from, in a full-height editor. — Edits are held in the browser's copy of the map. Your file on disk is not written to.

Types

The same canvas draws an org chart or a service map.

md2hd knows nothing about organisations, people, services or queues. It draws whatever types your notes declare, colours them from a palette of eight if you do not colour them yourself, and gets out of the way.

The md2hd canvas showing a service architecture map: services, datastores and queues as coloured cards with dependency links between them. — The second bundled sample. Same application, same language, entirely different vocabulary.

The map surface in md2hd: the panel lists every type in the map with its node count, above the visualization config for the whole map. — One crumb further up: every type the map declared, its count, and the config that applies to all of them.

Gaps

What you have not written yet still shows up.

Link to an id that does not exist and md2hd draws it as a placeholder rather than dropping the link. Nothing you reference goes missing, and the holes in a map become visible instead of silent. Write the block later and the placeholder fills in.

Help

The reference is in the app.

The whole language is one page, and it opens from the rail. It is the same file this site publishes as the reference, so the app and the docs cannot describe two different products.

The md2hd syntax sheet open over the canvas, showing the markdown language reference as formatted prose with code examples. — Opened from the rail, closed with Escape.

Honestly

What md2hd does not do.

Named here rather than left to be discovered. Most of these are decisions rather than gaps — the reasoning for each is inDecisions.

No node editing on the canvas: The Source tab, or your own editor. A form per node type would need a schema, and types are yours to invent.
No sharing, sync or multi-device: Nothing leaves the browser. That is the trade: privacy by architecture, at the cost of collaboration.
No nesting or groups: A map is flat. An organisation containing people is expressed as edges, not containment — the map ▸ type ▸ node trail browses that flat set, it is not a hierarchy in your markdown.
View config is per session: Hidden types and card artifacts reset when you open another map. Positions persist; what a card draws does not.
No surface for tags: Tags cross types freely, so they are a different axis rather than a deeper level. Hanging them off the breadcrumb would make it lie about containment.
Focus is one hop: One hop is the readable unit. Deeper neighbourhoods are read from the Connections list in the panel.
Object values render nothing: Strings, numbers, dates, booleans and arrays all render as rows. A nested map is skipped.
Passive wording is not invented: Half-working morphology is worse than none. Declare inverse pairs where the two sides use different words.
Local storage only: Roughly 5 MB per browser — a lot of markdown, but not a whole large vault. Import the folder you want to read.
Dark only: There is no light theme. The canvas is built on a dark ground and the type colours are tuned for it.

The fastest way to judge it is to open it.

Two sample maps are loaded already. If it is not obviously useful in two minutes, it is probably not for you.

Open the app Quickstart