Why does every value come out as a quoted string in the YAML output?

Because NestedText has no number, boolean, or null types, every value it stores is text by definition. When that text looks like it could be misread as something else, `3` looking like a number, `false` looking like a boolean, the YAML stringifier quotes it to guarantee the value stays a string if the YAML is parsed again, preserving exactly what NestedText originally meant.

How are multiline > blocks parsed?

Consecutive lines prefixed with `> ` under the same key or list item are joined with newlines into a single string value, in the order they appear, matching NestedText's own definition of a multiline string.

What happens with comment lines?

Lines whose first non-space character is `#` are treated as comments and skipped entirely, they contribute nothing to the parsed structure or the resulting YAML, the same as how NestedText itself defines comments.

What NestedText features aren't supported?

This parser covers the core constructs, mapping entries, list items, and multiline text blocks, but it doesn't implement inline dictionaries/lists (NestedText's optional compact `{...}`/`[...]` syntax in some implementations) or the full range of key-quoting edge cases; anything outside that produces a clear, line-numbered error.

Does this tool send my data anywhere?

No, parsing and YAML generation both happen entirely client-side using a small hand-written NestedText parser. Nothing you paste is uploaded.

NestedText to YAML Converter - Convert NestedText Online

Overview

Introduction

NestedText's minimal, everything-is-a-string format is easy to hand-edit but not every tool speaks it natively, most orchestration and CI systems expect YAML. This tool parses NestedText's core syntax and rebuilds it as nested YAML.

Because NestedText carries no type information, the resulting YAML deliberately keeps every value as a string rather than guessing that `3` should become a number or `true` should become a boolean, that guess would be a real information loss, not a convenience.

What Is NestedText to YAML Converter?

A NestedText-to-YAML converter reads NestedText line by line, using each line's indentation and leading marker (`key:`, `- `, or `> `) to determine whether it's a mapping entry, a list item, or a line of multiline text, and builds up the corresponding nested value.

That value, where every leaf is a string, is then serialized as YAML using the same stringifier every other tool in this category uses, quoting any value whose plain form would be misread as a different type when parsed again.

How NestedText to YAML Converter Works

The input is scanned into a flat list of line descriptors (indentation, type, and content), skipping blank lines and full-line comments. A recursive block parser then groups consecutive descriptors that share the same indentation and type into a single mapping, list, or multiline string, descending into deeper indentation wherever a `key:` or `-` line has no inline value.

Because siblings in a well-formed NestedText document must be homogeneous (all mapping entries, all list items, or all text lines), a change in type at the same indentation level is reported as a parse error rather than silently misinterpreted.

When To Use NestedText to YAML Converter

Use it when a NestedText-based config needs to feed into a YAML-only pipeline, CI system, or deployment tool.

It's also useful for double-checking how a NestedText document's structure is actually being interpreted, seeing it as YAML makes the nesting more visually explicit.

Often used alongside YAML to NestedText Converter, YAML to JSON Converter and YAML Formatter & Prettifier.

Features

Advantages

Correctly reconstructs arbitrarily nested mappings, lists, and multiline strings from NestedText's indentation-based syntax.
Never silently reinterprets a string as a number or boolean, preserving exactly what the source NestedText meant.
Reports clear, line-numbered errors for syntax outside the supported subset instead of guessing.
Runs entirely client-side with no added dependency, so configuration data never leaves your browser.

Limitations

Every converted value is a YAML string; if you need actual numbers or booleans, you'll need to adjust the YAML by hand afterward.
Inline compact dictionary/list syntax (where some NestedText tooling allows `{a: 1}` or `[1, 2]` on one line) is not supported by this parser.
Blank lines inside a multiline `> ` text block are not specially preserved as empty content lines; only lines with the `> ` marker are treated as part of the string.

Examples

A nested mapping

Input

config:
  debug: false

Output

config:
  debug: "false"

The value stays a quoted YAML string, since NestedText never distinguished it as a boolean in the first place.

A multiline text block

Input

note:
  > line1
  > line2

Output

note: |-
  line1
  line2

Consecutive `> ` lines are joined into a single multiline string and rendered as a YAML block scalar.

Best Practices & Notes

Best Practices

After converting, manually adjust any values that should be YAML numbers or booleans if your downstream tooling expects native types.
Keep source NestedText files free of inline compact syntax if you plan to convert them with this tool.
Use the reported line numbers to fix syntax errors directly in the original NestedText file, not just the converted output.

Developer Notes

The parser is hand-written and line-oriented (no NestedText library dependency), first tokenizing every line into a flat descriptor (indent, type, content) and then recursively grouping consecutive same-indent, same-type descriptors into mappings, lists, or joined multiline strings. This two-pass structure keeps the indentation logic isolated from the value-building logic, making it easier to report precise line numbers on error.

NestedText to YAML Converter Use Cases

Feeding a NestedText-based config into a YAML-only CI or deployment pipeline
Visualizing a NestedText document's nested structure as YAML for easier review
Migrating a project's configuration format from NestedText to YAML
Generating YAML fixtures for tests from an existing NestedText source

Common Mistakes

Expecting numeric or boolean-looking values to convert to native YAML types, they stay strings, matching what NestedText actually stored.
Mixing list items and mapping entries at the same indentation level, NestedText (and this parser) requires siblings to be consistent.
Using tabs for indentation, NestedText requires spaces, and this parser reports tab indentation as an explicit error rather than guessing at the intended depth.

Tips

If a document fails to parse, check the reported line for mixed sibling types first, it's the most common structural issue.
Use YAML to NestedText afterward to confirm a specific document round-trips the way you expect.
Run the result through the YAML Formatter if you want consistent indentation after conversion.

NestedText to YAML Converter