Yml is a reversible legality-and-display language for Tree and RunTree. It lets a human being see more structure than ordinary XML would normally reveal, while the underlying content remains safe for parsers, stable for transport, and recoverable back to its original ordinary meaning. The font matters, but the font is not the whole doctrine. The doctrine lives in the pact between stored XML-safe content, transform law, and visible glyph rendering.
Yml does not treat ordinary ASCII appearance as sacred. What matters is that the content remains lawful for XML and remains readable for the human. A visible mark may resemble a familiar digit, punctuation mark, brace, or reserved-looking token while actually occupying a protected, remapped, and reversible position. That is not a cosmetic trick. That is the heart of the doctrine.
The point is to allow Tree content to carry richer visible meaning than raw XML usually affords. Hidden things become visible. Dangerous things become shielded. Structural things become legible. And all of it can still be carried, parsed, and restored without guesswork.
The stored form must remain XML-safe. This is the legal substrate. Without this layer, the whole idea collapses into parser trouble.
ToYml and FromYml define the reversible mapping law. They are not helpers off
to the side. They are part of the doctrine itself.
YmlBold renders the mapped zone with richer visual meaning. The font does not invent the law;
it makes the law visible.
XML-safe content
↓
ToYml / FromYml transform
↓
YmlBold visible rendering
↓
Tree / RunTree becomes a readable operational surface
Ordinary XML has a hard edge. It is excellent for machine structure, but it tends to hide nuance from the human eye. Control intent vanishes. Certain name-like forms become suspicious. Punctuation often looks too plain to carry all the visual burden a living Tree wants to carry.
Yml answers that by moving selected content into a protected visible zone. What was formerly invisible, ambiguous, or parser-risky becomes displayable, colorable, and more immediately legible.
The doctrine therefore gains two kinds of value at once. It preserves the machine's need for lawfulness, and it serves the human's need for richer sight. That double gain is why Yml matters.
This is also why the Tree is not just a storage shape. It becomes a screen instrument. Once the glyphs can carry color, contrast, and class meaning, the Tree stops being a flat witness and becomes a live reading surface.
The xml-shield block is one of the most revealing parts of the design. Yml does not merely
remap single characters. It explicitly intercepts whole xml-looking triplets in all eight case patterns:
| Source | Target | Meaning |
|---|---|---|
XML | 0xEF | Uppercase shielded whole-form token. |
XMl | 0xF0 | Mixed-case shield variant. |
XmL | 0xF1 | Mixed-case shield variant. |
Xml | 0xF2 | Capitalized shield variant. |
xML | 0xF3 | Lower-leading shield variant. |
xMl | 0xF4 | Mixed-case shield variant. |
xmL | 0xF5 | Mixed-case shield variant. |
xml | 0xF6 | Lowercase shielded whole-form token. |
This tells us something important. Yml is not only about making punctuation prettier. It is protecting the Tree from forms that can look too close to parser-sensitive territory while still letting the user see a meaningful resemblance.
Another major gain is the recovery of things a normal text surface tends to hide. Line boundaries and tab intent are not thrown away into invisibility. They receive visible mapped witnesses:
| Source | Target | Class | Purpose |
|---|---|---|---|
CRLF | 0xEB | control-special | Visible line-pair witness. |
CR | 0xEC | control-special | Visible carriage-return witness. |
LF | 0xED | control-special | Visible linefeed witness. |
TAB | 0xEE | control-special | Visible tab witness. |
This is powerful because it lets the Tree display carry the memory of spacing and line intent without relying on a hidden editor behavior. The structure is visually declared rather than merely implied.
| Source band | Transform | Target band | Class | Reading |
|---|---|---|---|---|
0x20..0x40 |
+160 |
0xC0..0xE0 |
mapped-short | Space, punctuation, digits, and @ are pushed into a visible upper zone. |
0x5B..0x60 |
+134 |
0xE1..0xE6 |
mapped-bracket | Bracket and slash-adjacent forms get their own structural band. |
0x7B..0x7E |
+108 |
0xE7..0xEA |
mapped-brace | Brace, bar, and tilde move into a visibly distinct boundary band. |
These bands are a declaration that selected ordinary symbols deserve a second, richer life in the Tree. Digits can still be understood as digits. Braces can still be understood as braces. But they no longer have to remain trapped in their plain original shapes.
| Range | Result | Interpretation |
|---|---|---|
0x00..0x08 | plain | Left alone by the generic loop. |
0x09 | control-special | TAB maps first to 0xEE. |
0x0A | control-special | LF maps first to 0xED. |
0x0B..0x0C | plain | Remain plain. |
0x0D | control-special | CR maps to 0xEC; CRLF as a pair maps to 0xEB. |
0x0E..0x1F | plain | Remain plain in the generic loop. |
0x20..0x40 | mapped-short | Short visible band. |
0x41..0x5A | plain | Uppercase letters remain direct unless consumed as part of an XML shield token. |
0x5B..0x60 | mapped-bracket | Bracket-visible band. |
0x61..0x7A | plain + xml-shield | Lowercase letters remain direct unless matched as one of the shielded triplets. |
0x7B..0x7E | mapped-brace | Brace-visible band. |
0x7F | plain | Unchanged. |
Unchanged content gives the Tree its baseline readability. Not every mark needs ceremony.
This class makes line and tab intent visibly present. It helps the user read structure that ordinary XML hides.
This class warns that a reserved-looking form is being safely carried through a protected visible token.
These classes let punctuation, digits, and boundary symbols become visually richer and more operationally distinct.
Tre should therefore not present Yml as if it were plain body text. Tre should present it as stratified reading matter. Color is not decoration here. Color is doctrinal assistance. It tells the eye what kind of thing is being looked at: ordinary, control-derived, shielded, short-band, bracket-band, or brace-band.
The strongest technical virtue of Yml is that it does not force the system to choose between beauty and correctness.
Because FromYml is the true inverse of ToYml, the display-rich form can always return to the
ordinary meaning. That gives Yml discipline. The visible layer is expressive, but it is not lossy. The machine does not
become dependent on a fragile visual convention. The human gains richer sight, and the system keeps exact recoverability.
In other words: Yml is generous to the eye without becoming dishonest to the parser.
The Yml Window is not YAML, not a configuration editor, and not a generic text beautifier.
It is a viewing and reading surface for lawful transformation. Its purpose is to let the operator see
more of the Tree than raw XML normally reveals, while preserving the reversibility promised by
ToYml and FromYml.
This is the important distinction: the Window may show a mark that looks different from its stored substrate, but it may not lie about what happened. Shielded forms, mapped punctuation, control witnesses, and branch structure must remain readable as classes of meaning, not merely painted as decorative glyphs.
Window law: the display may be richer than the storage form, but it must never become less truthful than the storage form.
Plain ASCII is useful, but it is not holy. A digit may remain meaningful as a digit even when its visible carrier is moved into a protected display band. A brace may still read as a boundary even when the Window renders it with stronger color and shape. A line break may be more honest when shown as a witness than when hidden as whitespace.
The sacred obligations are legality, reversibility, and legibility. If those are preserved, the system is free to give the operator better sight than raw text provides. That is why YmlFont is a doctrine of lawful perception, not merely a font mapping exercise.
Control characters are often treated as background machinery. Yml rejects that invisibility when the operator is trying to read structure. A carriage return, line feed, CRLF pair, or tab can alter meaning, layout, grouping, and operational expectation. If the Window hides that completely, the Window becomes less truthful than the data.
CRLF should read as a paired line event, not merely two lost codes.
CR and LF should remain distinguishable when they arrive alone.
TAB should be visible as alignment intent, not silently collapsed into accidental spacing.
Control law: a control character that changes reading must be capable of becoming a visible witness.
Text is a stream. Tree is a situated reading. Text can be scanned from left to right, but Tree asks the eye to understand parentage, branch, node, residue, and class. YmlFont belongs to Tree because the Tree needs visible class language. The Window is therefore not merely showing characters; it is staging a structured situation.
RunTree inherits the same need. A running Tree cannot depend on raw text alone when the operator needs to distinguish ordinary content, mapped content, shielded forms, and control witnesses during movement. The Window is the place where that movement remains readable without breaking the stored law underneath.
This Pen keeps its custom styling and small helper script inside the body so the PenPals assembly process can lift the body content without losing the local look, the reading-window miniature, or the fold behavior. The page remains a complete standalone document, but the doctrinal cargo lives where PenPals can gather it.
Yml is really a doctrine about respect for both sides of the system. It respects the machine by staying lawful, explicit, and reversible. It respects the human by refusing to collapse everything into mute plain text. That is why it fits Tre and RunTree so well. A Tree should not only be valid. A Tree should be readable as a living thing.
Once this doctrine is combined with strata-aware rendering, a network-borne Tree can become far more than a file viewer. It becomes a structured screen language: lawful enough for XML, expressive enough for operation, and rich enough to carry visual intent across devices.