Writing Markdown Documents with Type in Traverse

An outline is often the quickest way to find the shape of a piece of writing. You begin with sections, add supporting points, rearrange the order and gradually discover what the finished document needs to say.

The awkward part usually comes next. A conventional outliner knows that one item sits beneath another, but it does not know whether either item is meant to become a heading, a paragraph, a quotation or a list item. You have to rebuild that meaning when you move into a writing app.

Traverse’s Type attribute closes that gap. It lets every node carry a document role while remaining part of the outline. When you export as a Markdown Document, Traverse uses those roles to produce semantic Markdown rather than turning the whole hierarchy into one long list.

Writer view makes that relationship especially direct. It presents the outline as a continuous document, but every paragraph is still a node that can be nested, moved, focused, filtered or viewed in Columns. You can write with the rhythm of a conventional editor without giving up the structure that made the outline useful.

This guide explains when Type is useful, how its roles work, and how to build and export a short structured document from beginning to end.

What Type does

Type is a built-in Traverse attribute. Once it is enabled for an outline, each node can be one of the following:

• Body — ordinary paragraph text. This is the default.
• Heading — a Markdown heading. Heading depth follows the heading structure in your outline.
• Blockquote — quoted material, exported with Markdown’s > syntax.
• Code block — preformatted text inside a fenced Markdown code block.
• Bullet — an unordered list item.
• Numbered bullet — an ordered list item.
• Divider — an optional horizontal rule in the exported document.
• Note — a standalone note in the outline hierarchy, exported using the document’s note settings.

The text of the node is still the text you edit and rearrange. Type simply tells Traverse what that text means when it is displayed and exported.

This is different from Traverse’s Markdown List export. Markdown List preserves the outline as a nested list. Markdown Document is the export that interprets Type and turns the outline into document blocks.

When Type is the right tool

Type is especially useful when the outline is not merely planning a document but is becoming the document.

Good examples include:

• Articles and blog posts with sections, prose and supporting lists.
• Reports that mix headings, findings, quotations and recommendations.
• Technical documentation containing explanation and code samples.
• Course or workshop material with sections, instructions and exercises.
• Project briefs that need to become readable Markdown for a repository, wiki or publishing system.
• Book or long-form writing plans where the structure is still changing.

You do not need Type for every outline. If the result should remain an outline, ordinary hierarchy and Markdown List export may be enough. Add Type when the distinction between a section title, a paragraph and a list item matters to the next stage of the work.

Type and Fountain are alternative structural attributes: one outline cannot enable both at the same time. Use Type for general Markdown documents and Fountain for screenplays.

Three ways to assign a Type

Once Type is enabled, you can work in whichever way suits the moment.

1. Click the Type icon on a node and choose its role from the picker.
2. Use the Format menu, which lists the available roles and their Control-Command-number keyboard shortcuts.
3. Use smart Type entry by beginning a line with a familiar Markdown marker followed by a space.

Smart Type entry removes the marker from the visible node text and assigns the corresponding role:

The space matters. Typing #Research remains ordinary text; typing # Research changes the node to Heading and leaves Research as its text.

New lines inherit an appropriate role so repeated paragraphs or list items stay quick. If a fresh line inherited a role you do not want, press Backspace at the beginning of the empty line to return it to the default Body role.

Tutorial: build a short practical guide

We will create a small document called A calm pre-flight checklist. The finished export will contain headings, paragraphs, bullets, a quotation and a divider.

Step 1: create the outline

Create a blank outline and change its title to A calm pre-flight checklist. Switch to Writer view with Command-2 if you want to build it as a continuous document.

Add the following nodes. Indentation shows the hierarchy to create in Traverse:

Why a checklist helps
    A short checklist protects attention when the pressure rises.
    Slow is smooth; smooth is fast.
What to check
    Confirm the destination and route.
    Check weather and travel notices.
    Save the booking details offline.
    Tell someone when you expect to arrive.
Final review
    Put the essentials where you can reach them, then stop checking.
End

You can build this quickly from the keyboard. In Writer view, Return adds the next sibling, Shift-Return adds a child, and Tab or Shift-Tab changes the current node’s indentation. The exact wording is not important; the aim is to have a real structure on which to practise.

Try it quickly: Copy the complete text from above and paste it into a blank Traverse outline. Each line becomes a node, and Traverse preserves the indentation as parent-child hierarchy—there is no need to recreate the structure manually.

Step 2: add Type to the outline

Open the Inspector. If it is hidden, show it from the Inspector control or the app’s menu bar.

At the top of the Inspector, click the + button to open the Attributes sheet. Under Add Defaults, choose Type, then click Done.

Adding Type requires Traverse Pro. If an outline already contains Type, its roles remain usable even when Pro is not active; Pro is required when adding Type to another outline.

If Type is unavailable because Fountain is already present, remove Fountain before adding it. Removing an attribute removes it and its values throughout that document, so only do this when you genuinely want to change the outline’s structural mode.

Step 3: turn the section titles into headings

Select Why a checklist helps. Click its Type icon or use the Inspector and choose Heading.

If you are creating the text rather than converting an existing node, type # Why a checklist helps instead. As soon as you type the space after #, Traverse applies Heading and removes the marker.

Repeat this for:

• What to check
• Final review

Leave their explanatory children as Body. Body is the default, so you do not have to set it explicitly.

Heading levels come from the heading relationships in the outline. A Heading beneath another Heading becomes a deeper Markdown heading. Body nodes do not force subsequent headings to become deeper merely because they are indented beneath them. This lets you keep related material together without accidentally distorting the document’s section structure.

Step 4: assign the other roles

Select Slow is smooth; smooth is fast. and set Type to Blockquote. When writing from scratch, starting the line with > produces the same result.

Set each of the four children beneath What to check to Bullet. You can do them together:

1. Select the first bullet candidate.
2. Command-click the other three so all four are selected.
3. In the batch Inspector, set Type to Bullet.

Finally, select End and set Type to Divider. Alternatively, type --- on an empty line to create the Divider directly. A Divider is shown as a structural rule in Writer view and can become a horizontal rule in the exported document.

At this point, the outline hierarchy expresses where the material belongs and Type expresses what each piece is.

Step 5: make Type visible while you work

Traverse can display Type and Fountain indicators on nodes. Turn on Show Type and Fountain Icons in Nodes if you want to scan the structure without repeatedly looking at the Inspector.

You can also enable Show Attributes in Nodes when you want more attribute context in the outline itself. These are display choices; they do not change the saved structure or export.

For a longer document, use the filter controls and choose Type to isolate headings, quotations, code blocks or another role. This is useful for reviewing one semantic layer at a time—for example, checking that the heading sequence reads clearly without the body copy around it. Attribute filters are a Traverse Pro feature.

Step 6: choose the Markdown Document options

Open Settings, choose Export, then select Markdown Document.

The available options let you decide how the document should be formed:

• Use document title as H1 makes the outline title the top Markdown heading. Typed headings then begin at H2.
• Notes controls whether the export includes attribute notes, Note nodes, both kinds or neither.
• Note format controls whether included notes become body text, italicised text, HTML comments, or use // or %% formatting.
• Include task status turns nodes using the Task attribute into Markdown task items.
• Export dividers as horizontal rules determines whether Divider nodes produce --- or are omitted.
• Include additional attributes can include useful metadata from other attributes.
• Preserve numbering carries Traverse’s generated numbering into the text.

For this tutorial, turn on Use document title as H1 and Export dividers as horizontal rules. Leave the other options at their defaults.

Step 7: export the document

Choose Export → Markdown Document… from the menu bar, choose a location and save the file.

The result will follow this general shape:

# A calm pre-flight checklist

## Why a checklist helps

A short checklist protects attention when the pressure rises.

> Slow is smooth; smooth is fast.

## What to check

- Confirm the destination and route.
- Check weather and travel notices.
- Save the booking details offline.
- Tell someone when you expect to arrive.

## Final review

Put the essentials where you can reach them, then stop checking.

---

The source outline remains fully editable. If the order is wrong, move nodes in Traverse and export again. If a sentence should become a section, change its Type to Heading rather than rewriting the document by hand.

Attribute notes and Note nodes

Traverse offers two complementary ways to keep notes alongside your writing.

An attribute note is stored directly on a node as metadata. It does not sit above or below anything in the outline hierarchy: it belongs to the node itself. This makes attribute notes useful for internal editorial context, research reminders and instructions that should travel with a paragraph or section as you move it.

A Note node is a regular outline node whose Type is set to Note. It has its own place in the hierarchy, can have siblings or children, and can be moved, focused and filtered like other nodes. Traverse displays Note nodes in subdued italic text so they remain distinct from document prose. Create one manually from the Type picker or Format menu, or begin a line with : while smart Type entry is available.

This separation lets you use the two approaches for different purposes. For example, attribute notes might hold private working instructions while Note nodes contain commentary or supporting information that you want to pass into another app with the exported document.

In Settings → Export → Markdown Document, the Notes menu lets you choose:

• Don't export
• Export attribute notes
• Export node notes
• Export all notes

The separate Note format setting is then applied consistently to whichever notes you include. A Note node’s text becomes the exported note content; an attribute note uses the note text attached to its node.

Starting with existing Markdown or text

Traverse Pro can import Markdown and plain-text files as editable outlines. Importing Markdown recognises document structures such as headings, paragraphs, lists, quotations, code blocks and dividers where possible and brings them into a Type-based outline. You can then move sections, change roles and continue in Writer, Outline or Column view before exporting again.

Plain text can also become an outline. When you paste multiple lines into Traverse, each line becomes a node and leading indentation is preserved as parent-child structure. This is useful for moving an indented plan, rough notes or generated text into the app without rebuilding the hierarchy by hand.

Import is a good starting point, not a promise that every Markdown convention carries an unambiguous outline structure. Review the heading relationships and any complex nested material after import, then use the Type icon, Format menu or smart entry to make adjustments.

Track the work around the document

Type describes what a node is in the finished document: a Heading, Body paragraph, Blockquote, list item or another structural role. Tasks and custom attributes answer a different question: what still needs to happen to it? You can use both layers together without putting editorial instructions into the prose.

Use Tasks for visible progress

Add the built-in Task attribute when sections or individual points have a clear completion state. A heading might be In progress while its argument is being developed, a paragraph can remain Not started until its research is complete, and a settled section can be marked Done.

Filtering by Task gives you an immediate working list of unfinished areas, even when those nodes are distributed across a long document. If several nodes have reached the same stage, select them together and update their Task state in one action.

For Markdown export, Include task status can turn those nodes into Markdown task items. Leave that option off when Tasks are purely an internal editorial system and should not appear in the finished document.

Add custom attributes for recurring editorial questions

Traverse Pro custom attributes are useful when the same question applies throughout the document. For example:

• A Stage Lookup with values such as Idea, Drafting, Review and Ready.
• A Needs research or Needs fact-check Checkbox.
• An Owner String or Lookup when several people are contributing.
• A Review date Date for material that should be revisited.
• A Confidence Number for claims or sections that need stronger support.

These values remain attached when you move a node, so its editorial context travels with the writing. Show attributes on nodes when you want that context visible, or filter by one of them to gather every section awaiting research, review or approval.

Custom attributes do not have to appear in the published Markdown. Keep them as working metadata, or deliberately include suitable fields using the Markdown Document export’s Include additional attributes option. This separation lets the document stay readable while Traverse carries the workflow behind it.

A few useful refinements

Keep rough alternatives as drafts

Every node has a Draft checkbox in the Inspector. Draft nodes and their descendants are omitted from Markdown export, which makes them useful for alternate passages, reminders and material that is not ready to leave the working outline.

Keep comments in notes, not in the prose

If a paragraph needs an editorial reminder, put it in the node’s Note attribute so it stays attached to that paragraph as metadata. Use a standalone Note node when the note needs its own place in the hierarchy or you may want to pass it onward in the export. The Markdown Document settings let you export attribute notes, Note nodes, both, or neither, using your chosen note format.

Use Type selectively

You do not need to assign a non-default Type to every node. Most prose can remain Body. Add roles where they carry real meaning: Heading for structure, Blockquote for quoted material, Code block for code, and list roles for actual lists.

Review roles in batches

Multi-selection is helpful when an imported or rapidly captured outline contains many nodes that need the same role. Select them together and make one change in the batch Inspector. The change can be undone as a single action.

The main idea

Type lets an outline acquire meaning gradually.

You can begin with nothing more than nested thoughts. When the shape becomes clearer, mark the sections as headings, turn evidence into quotations, identify list items and keep code as code. Traverse remains the place where you navigate and rearrange the work, while Markdown Document export becomes a reliable way to send that work onward.

That removes an unnecessary hand-off: the outline does not have to be discarded just as it becomes useful.